A Dart package for generating HTTP Basic Authentication headers from username and password.
- ✅ Generate Basic Auth headers: Convert username/password to HTTP headers
- ✅ Decode headers: Extract username/password from existing headers
- ✅ Validate headers: Check if headers are valid Basic Auth format
- ✅ Generate commands: Create cURL and JavaScript code with authentication
- ✅ Error handling: Comprehensive error handling with Result types
- ✅ Unicode support: Handle special characters and Unicode in credentials
- ✅ Round-trip conversion: Encode and decode without data loss
Add this to your package's pubspec.yaml file:
dependencies:
fpd_basic_auth_generator: ^1.0.0Then run:
dart pub getimport 'package:fpd_basic_auth_generator/fpd_basic_auth_generator.dart';
void main() {
// Generate Basic Auth header
final result = FpdBasicAuthGenerator.generateHeader('user', 'pass');
if (result.isSuccess) {
print(result.data!.header); // Authorization: Basic dXNlcjpwYXNz
}
// Decode existing header
final decodeResult = FpdBasicAuthGenerator.decodeHeader('Authorization: Basic dXNlcjpwYXNz');
if (decodeResult.isSuccess) {
print('Username: ${decodeResult.data!.username}'); // user
print('Password: ${decodeResult.data!.password}'); // pass
}
}Generates a complete HTTP Basic Authentication header.
final result = FpdBasicAuthGenerator.generateHeader('admin', 'secret123');
if (result.isSuccess) {
print(result.data!.header); // Authorization: Basic YWRtaW46c2VjcmV0MTIz
print(result.data!.base64Credentials); // YWRtaW46c2VjcmV0MTIz
print(result.data!.username); // admin
print(result.data!.password); // secret123
}Generates only the Base64 credentials part.
final result = FpdBasicAuthGenerator.generateCredentials('user', 'pass');
if (result.isSuccess) {
print(result.data); // dXNlcjpwYXNz
}Decodes a complete Basic Auth header to extract username and password.
final result = FpdBasicAuthGenerator.decodeHeader('Authorization: Basic dXNlcjpwYXNz');
if (result.isSuccess) {
print('Username: ${result.data!.username}'); // user
print('Password: ${result.data!.password}'); // pass
}Decodes Base64 credentials to extract username and password.
final result = FpdBasicAuthGenerator.decodeCredentials('dXNlcjpwYXNz');
if (result.isSuccess) {
print('Username: ${result.data!.username}'); // user
print('Password: ${result.data!.password}'); // pass
}Checks if a string is a valid Basic Auth header.
final isValid = FpdBasicAuthGenerator.isValidHeader('Authorization: Basic dXNlcjpwYXNz');
print(isValid); // trueChecks if a string is valid Base64 credentials.
final isValid = FpdBasicAuthGenerator.isValidCredentials('dXNlcjpwYXNz');
print(isValid); // trueGenerates a cURL command with Basic Auth.
final result = FpdBasicAuthGenerator.generateCurl(
'https://api.example.com/data',
'user',
'pass',
method: 'POST',
);
if (result.isSuccess) {
print(result.data);
// curl -X POST -H "Authorization: Basic dXNlcjpwYXNz" "https://api.example.com/data"
}Generates JavaScript fetch code with Basic Auth.
final result = FpdBasicAuthGenerator.generateJavaScript(
'https://api.example.com/data',
'user',
'pass',
);
if (result.isSuccess) {
print(result.data);
// fetch('https://api.example.com/data', {
// method: 'GET',
// headers: {
// 'Authorization': 'Basic dXNlcjpwYXNz'
// }
// })
// .then(response => response.json())
// .then(data => console.log(data))
// .catch(error => console.error('Error:', error));
}Contains all information about a Basic Auth header.
class BasicAuthHeader {
final String header; // Full header: "Authorization: Basic ..."
final String base64Credentials; // Base64 part only
final String username; // Extracted username
final String password; // Extracted password
}Generic result wrapper for success/failure handling.
class Result<T> {
final T? data; // Success data (null on failure)
final String? error; // Error message (null on success)
bool get isSuccess; // true if successful
bool get isFailure; // true if failed
}import 'package:fpd_basic_auth_generator/fpd_basic_auth_generator.dart';
void main() {
// Generate header
final result = FpdBasicAuthGenerator.generateHeader('admin', 'secret123');
if (result.isSuccess) {
print('Header: ${result.data!.header}');
// Output: Header: Authorization: Basic YWRtaW46c2VjcmV0MTIz
}
}void decodeExample() {
final header = 'Authorization: Basic dXNlcjpwYXNz';
final result = FpdBasicAuthGenerator.decodeHeader(header);
if (result.isSuccess) {
print('Username: ${result.data!.username}'); // user
print('Password: ${result.data!.password}'); // pass
} else {
print('Error: ${result.error}');
}
}void validationExample() {
final headers = [
'Authorization: Basic dXNlcjpwYXNz',
'Invalid: Header',
'Authorization: Bearer token',
];
for (final header in headers) {
final isValid = FpdBasicAuthGenerator.isValidHeader(header);
print('$header: ${isValid ? "Valid" : "Invalid"}');
}
}void commandExample() {
// Generate cURL command
final curlResult = FpdBasicAuthGenerator.generateCurl(
'https://api.example.com/users',
'admin',
'secret123',
method: 'GET',
);
if (curlResult.isSuccess) {
print('cURL: ${curlResult.data}');
}
// Generate JavaScript code
final jsResult = FpdBasicAuthGenerator.generateJavaScript(
'https://api.example.com/users',
'admin',
'secret123',
);
if (jsResult.isSuccess) {
print('JavaScript: ${jsResult.data}');
}
}void errorHandlingExample() {
// Empty username
final result1 = FpdBasicAuthGenerator.generateHeader('', 'pass');
if (result1.isFailure) {
print('Error 1: ${result1.error}'); // Username cannot be empty
}
// Invalid header format
final result2 = FpdBasicAuthGenerator.decodeHeader('Invalid Header');
if (result2.isFailure) {
print('Error 2: ${result2.error}'); // Invalid header format
}
// Invalid Base64
final result3 = FpdBasicAuthGenerator.decodeCredentials('invalid_base64!@#');
if (result3.isFailure) {
print('Error 3: ${result3.error}'); // Error decoding credentials
}
}void roundTripExample() {
const username = 'testuser';
const password = 'testpass123';
// Generate header
final headerResult = FpdBasicAuthGenerator.generateHeader(username, password);
if (headerResult.isSuccess) {
print('Generated: ${headerResult.data!.header}');
// Decode header
final decodeResult = FpdBasicAuthGenerator.decodeHeader(headerResult.data!.header);
if (decodeResult.isSuccess) {
print('Decoded username: ${decodeResult.data!.username}');
print('Decoded password: ${decodeResult.data!.password}');
// Verify round-trip
final isCorrect = username == decodeResult.data!.username &&
password == decodeResult.data!.password;
print('Round-trip successful: $isCorrect'); // true
}
}
}HTTP Basic Authentication is a simple authentication scheme that:
- Combines username and password in format
username:password - Encodes the combination in Base64
- Includes the result in header
Authorization: Basic <credentials>
Username: admin
Password: secret123
Combined: admin:secret123
Base64: YWRtaW46c2VjcmV0MTIz
Header: Authorization: Basic YWRtaW46c2VjcmV0MTIz
- REST APIs: Authenticate API requests
- Web Services: Secure service communication
- Application Authentication: Simple client-server auth
- Testing: Validate authentication endpoints
Run the tests:
dart testRun with coverage:
dart test --coverage=coverage
genhtml coverage/lcov.info -o coverage/html- Dart SDK:
>=3.7.0 <4.0.0 - Dependencies:
meta: ^1.11.0
- Fork the repository
- Create a feature branch
- Make your changes
- Add tests for new functionality
- Run the tests
- Submit a pull request
This project is licensed under the MIT License - see the LICENSE file for details.
- fpd_base64_string_converter - Base64 string encoding/decoding
- fpd_encryption - Encryption utilities
- fpd_hash_text - Text hashing utilities
- Issues: GitHub Issues
- Discussions: GitHub Discussions
- Email: support@flutterpilot.dev
Made with ❤️ by the FlutterPilot team