Free ntlm authorization software for linux

NTLM authentication library (libntlm) is a library that implement Microsofts NTLM authentication.
However, the packaging of libntlm lacked certain things, such as having build problems, lacking shared library support, lacking autoconf macro for use in other applications, lacking pkg-config support, and more. So this page distributes an improved version of the library; called Libntlm.
Libntlm is licensed under the GNU Lesser General Public License.
Projects using Libntlm include GNU SASL.
Enhancements:
- This release adds new APIs to access the SMBencrypt and SMBNTencrypt functions.
- The library is now linked with -no-undefined to enable building a Windows DLL.

CGI::Application::Plugin::Authorization is an authorization framework for CGI::Application.

SYNOPSIS

use base qw(CGI::Application);
use CGI::Application::Plugin::Authentication;
use CGI::Application::Plugin::Authorization;

# default config for runmode authorization
__PACKAGE__->authz->config(
DRIVER => [ HTGroup, FILE => htgroup ],
);

# Using a named configuration to distinguish it from
# the above configuration
__PACKAGE__->authz(dbaccess)->config(
DRIVER => [ DBI,
DBH => $self->dbh,
TABLES => [user, access],
JOIN_ON => user.id = access.user_id,
CONSTRAINTS => {
user.name => __USERNAME__,
access.table => __PARAM_1__,
access.item_id => __PARAM_2__
}
],
);

sub admin_runmode {
my $self = shift;

# User must be in the admin group to have access to this runmode
return $self->authz->forbidden unless $self->authz->authorize(admin);

# rest of the runmode
...
}

sub update_widget {
my $self = shift;
my $widget = $self->query->param(widget_id);

# Can this user edit this widget in the widgets table?
return $self->authz->forbidden unless $self->authz(dbaccess)->authorize(widgets => $widget);

# save changes to the widget
...
}

CGI::Application::Plugin::Authorization adds the ability to authorize users for specific tasks. Once a user has been authenticated and you know who you are dealing with, you can then use this plugin to control what that user has access to. It imports two methods (authz and authorization) into your CGI::Application module. Both of these methods are interchangeable, so you should choose one and use it consistently throughout your code. Through the authz method you can call all the methods of the CGI::Application::Plugin::Authorization plugin.

amed Configurations

There could be multiple ways that you may want to authorize actions in different parts of your code. These differences may conflict with each other. For example you may have runmode level authorization that requires that the user belongs to a certain group. But secondly, you may have row level database authorization that requires that the username column of the table contains the name of the current user. These configurations would conflict with each other since they are authorizing using different information. To solve this you can create multiple named configurations, by specifying a unique name to the c< authz > method.

__PACKAGE__->authz(dbaccess)->config(
DRIVER => [ DBI, ... ],
);
# later
$self->authz(dbaccess)->authorize(widgets => $widget_id);

CGI::Application::Plugin::Authorization::Driver::DBI is a Perl module with DBI Authorization driver.

SYNOPSIS

use base qw(CGI::Application);
use CGI::Application::Plugin::Authorization;

# Simple task based authentication
__PACKAGE__->authz->config(
DRIVER => [ DBI,
TABLES => [account, task],
JOIN_ON => account.id = task.accountid,
USERNAME => account.name,
CONSTRAINTS => {
task.name => __PARAM_1__,
}
],
);
if ($self->authz->authorize(editfoo) {
# User is allowed access if it can editfoo
}

This Authorization driver uses the DBI module to allow you to gather authorization information from any database for which there is a DBD module. You can either provide an active database handle, or provide the parameters necesary to connect to the database.

Pluto Request Action Library allows you to create a client/server application, where client sends requests, server replies with responses and optional actions. Very object oriented, and takes only minutes to get going. Same library used for both server & client side.

How does it work?

The client creates "Requests" which it sends to the server. The server will process the request, set some return variables, and can optionally add "Actions" it wants the client to execute in response. An example is a cashiers computer (the client) sends the central credit card processing server a request to "process a credit card", the server responds with the authorization code and also includes an action "give customer a message" which causes a message to appear on the cashiers computer.
Both the client and server use the same library. Both create an instance of RA_Processor.

The only difference is the server calls "ReceiveRequest" and the client creates the actual requests, and calls RA_Processors "SendRequest".
To create a request, just create a class derived from RA_Request. Add some member variables for the request and variables for the response. Your request must be derived from SerializeClass--a base class that facilitates taking an object (a request in this case), serializing the variables into a binary block, and then on the other end reconstructing the class with all the data. The framework handles everything. You just add the data members.

In the above example, the request variables would probably be the credit card information and maybe the customer ID, and the response variables would be the authorization code. RA_Request has a pure virtual function "ProcessRequest" which will be called on the server to handle the request. Both the client and the server have the same Request/Action classes. When the client side passes a request to the RequestProcessor, the framework handles serializing all the request member variables, making the socket connection to the server and sending the request to the server.

On the server, the framework will create an instance of the request class and deserialize all the data and call the "ProcessRequest" member function. That is the only function the server needs to implement. From within ProcessRequest, the server needs to set the response variables. When ProcessRequest returns, the framework will serialize the response variables, send them back to the client, update the clients original request with the response, and execution will continue. Less than 10 lines of code are required to make it work, and the project includes a sample client/server application you can extend.

Meldware Communication Suite is a platform independent groupware package consisting of:
Meldware Mail
Meldware Calendar
Meldware Webmail
Meldware Secure Administration System
Together the package provides support for thousands of users to concurrently send and receive email and schedule meetings. MCS uniquely allows you to store all messages and scheduling events in nearly any database and runs on nearly all popular software and hardware platforms.
Additionally, while the scheduling and calendaring services are able to be installed separately, the integrated featureset provides both a unique and powerful experience to both users and server-side Mail Based Applications and Collaboration Based Application Services.
The MCS platform provides security integration using LDAP sources including Microsoft Active Directory as well as flat-file and Database sources. Additionally, extensible security allows custom authentication/authorization sources.
Enhancements:
- IMAP is now stable with Mozilla Thunderbird and POP/SMTP are production ready.
- New Filestore code was implemented and many improvements were made in mailbox and storage code.

Business::OnlinePayment::iAuthorizer is an iAuthorizer.net backend for Business::OnlinePayment.

SYNOPSIS

use Business::OnlinePayment;

my $tx = new Business::OnlinePayment("iAuthorizer");
$tx->content(login => ..., # login, password, and serial for your account
password => ...,
serial => ...,
action => Normal Authorization,
card_number => 4012888888881, # test card
expiration => 05/05,
amount => 1.00,
address => 123 Anystreet,
zip => 12345,
cvv2 => 1234,
);

$tx->submit();

if($tx->is_success()) {
print "Card processed successfully: ".$tx->authorization."n";
} else {
print "Card was rejected: ".$tx->error_message."n";
}

mod_auth_vas is an Apache authentication and authorization module for use with the Apache Web server.
The module uses Vintela Authentication Services (VAS) to implements the HTTP SPNEGO protocol, with optional fallback to Basic authentication for browsers that do not support SPNEGO.
In effect, using mod_auth_vas allows the Apache Web server to perform Windows integrated (single sign-on) authentication.
Browsers that can authenticate using SPNEGO automatically (without prompting for a password) include Internet Explorer and Firefox (with appropriate plugin).
Enhancements:
- This release includes a new AuthVasLocalizeRemoteUser option and a more comprehensive setup script.
- Bugfixes include a fix for users being locked out when using Basic authentication and build problems with some configurations.