Generating base64-encoded Authorization headers in a variety of languages

example.cs

httpClient.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue(
        "Basic", 
        Convert.ToBase64String(
            System.Text.ASCIIEncoding.ASCII.GetBytes(
                string.Format("{0}:{1}", username, password))));

example.php

$header = "Authorization: Basic " . base64_encode($username . ':' . $password);

example.py

base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
header = ("Authorization: Basic %s" % base64string)   

example.rb

$header = 'Authorization: Basic ' + Base64.encode64( username + ':' + password ).chomp

jquery.js

$.ajax
({
  type: "GET",
  url: "https://www.example.com",
  dataType: 'json',
  headers: {
    "Authorization", btoa(username + ":" + password)
  },
  data: '{}',
  success: function (){
   ...
  }
});

node.js

var username = 'Test';
var password = '123';
var auth = 'Basic ' + new Buffer(username + ':' + password).toString('base64');

var header = {'Host': 'www.example.com', 'Authorization': auth};
var request = client.request('GET', '/', header);

In Bash:

username='Test'
password='123'
credentials="$(echo -n "$username:$password" | base64)"
header="Authorization: Basic $credentials"

In Swift:

let username = "Test"
let password = "123"
let base64encoded = "\(username):\(password)".data(using: .isoLatin1)?.base64EncodedString() ?? ""
urlRequest.addValue("Basic \(base64encoded)", forHTTPHeaderField: "Authorization")

In zsh:

 #!/bin/zsh
 read "username?Enter a username: "
 read "password?Enter a password: "
 credentials="$(echo -n "$username:$password" | base64)"
 header="Authorization: Basic $credentials"
 echo $header

PowerShell

$username = 'test'
$password = 'password'
$base64AuthInfo = [convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1} -f $username, $password")))
$base64AuthInfo

In SAS 9.4:

proc fcmp outlib=work.func.cipher;
function b64(string $) $;
length digest $32767;
digest=strip(put(string,$base64x32767.));
return(digest);
endsub;
quit;
options cmplib=(work.func);
data _null_;
string='myUserID:MyPasword';
b64=b64(string);
put b64;
run;

*** Encoded result will be in the log;

example.rb

$header = 'Authorization: Basic ' + Base64.encode64( username + ':' + password ).delete("\n")

Scala:

val bytesFromString = (username ++ ":" ++ password).getBytes("UTF-8")
val urlAuth = "Basic " ++ Base64.encode(bytesFromString)

Dart:

final auth = "Basic " + BASE64.encode(UTF8.encode("${username}:${password}"));

Ruby should use the strict_encode64 method otherwise using long usernames or passwords will end up with a line break:
$header = 'Authorization: Basic ' + Base64.strict_encode64( username + ':' + password ).chomp

Java + Spring Framework:

String authString = "Authorization: Basic " +
                Base64Utils.encodeToString(
                        String.format("%s:%s", username,password)
                                .getBytes()
                );

Vanilla Java:

String authString = "Authorization: Basic " +
                Base64.getEncoder().encodeToString(
                        String.format("%s:%s", username,password)
                                .getBytes()
                );

Node Aug '18 update:

const username = 'test',
    password = 'supersecret01!',
    auth = (Buffer.from(`${username}:${password}`).toString('base64')

Python3 update: encodestring is deprecated (DeprecationWarning: encodestring() is a deprecated alias since 3.1, use encodebytes()).
I think you should change the snippet to be:

base64string = base64.encodebytes(('%s:%s' % (username, password)).encode('utf8')).decode('utf8').replace('\n', '')
header = ("Authorization: Basic %s" % base64string)   

or, if you prefer a bytes-like str:

base64string = base64.encodebytes(('%s:%s' % (username, password)).encode('utf8')).replace(b'\n', b'')

Perl:
'Authorization: Basic ' . MIME::Base64::encode("$username:$password")

Better Perl (avoid line breaks):

'Authorization: Basic ' . MIME::Base64::encode("$username:$password", '')

https://gist.github.com/brandonmwest/a2632d0a65088a20c00a#gistcomment-2345632

PowerShell

$username = 'test'
$password = 'password'
$base64AuthInfo = [convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1} -f $username, $password")))
$base64AuthInfo

This in incorrect, the enclosing double quote should be after {1}, not $password.

$username = 'test'
$password = 'password'
$base64AuthInfo = [convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1}" -f $username, $password)))
$base64AuthInfo

In Free Pascal:

uses base64;

header := EncodeStringBase64(Concat(username, ':', password));

in Golang:

client := &http.Client{}
request, err := http.NewRequest("POST","https://example.com", nil)

encodedCredential := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", CLIENT_ID, CLIENT_SECRET)))
request.Header.Add("Authorization", fmt.Sprintf("Basic %s", sEnc))

Line 7 correction for jquery snippet: "Authorization", "Basic " + btoa(username + ":" + password)

PowerShell

$username = 'test'
$password = 'password'
$base64AuthInfo = [convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1} -f $username, $password")))
$base64AuthInfo

The code above doesn't work. Below is the fix.

$username = 'test'
$password = 'password'
$base64AuthInfo = [convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("${username}:${password}")))
$base64AuthInfo

Scala:

val bytesFromString = (username ++ ":" ++ password).getBytes("UTF-8")
val urlAuth = "Basic " ++ Base64.encode(bytesFromString)

The right scala implementation which run directly :

  val tokenBytes = s"$username:$password".getBytes("UTF-8")
  val tokenB64 = new String(java.util.Base64.getEncoder.encode(tokenBytes))
  val token = s"Basic $tokenB64"

in JQuery, aren't we missing the 'Basic ' prefix?

in Rust;

use http_auth_basic::Credentials;

let credentials = Credentials::new("username", "password").as_http_header();

assert_eq!(String::from("Basic dXNlcm5hbWU6cGFzc3dvcmQ="), credentials);

In Elixir:

username = "username"
password = "password"

"#{username}:#{password}"
|> Base.encode64()

In kotlin:

val username = "username"
val password = "password
val userpass = username + ":" + password
val encodedAuth = encodeToString(userpass.toByteArray(), NO_WRAP)
val authHeaderValue = "Basic " + encodedAuth
httpURLConnection.setRequestProperty("Authorization", authHeaderValue)

In Salesforce APEX

HttpRequest request = new HttpRequest();
String username = 'test';
String password = 'test';

String accessToken = EncodingUtil.base64Encode(Blob.valueOf(username + ':' + password));
request.setHeader('Authorization', 'Basic ' + accessToken);

In oracle pl/sql

set serveroutput on;
DECLARE
v_str VARCHAR2(1000);
BEGIN
--Create encoded value
v_str := utl_encode.text_encode('Testuser:verySecret','WE8ISO8859P1', UTL_ENCODE.BASE64);
dbms_output.put_line(v_str);
--Decode the value..
v_str := utl_encode.text_decode(v_str,'WE8ISO8859P1', UTL_ENCODE.BASE64);
dbms_output.put_line(v_str);
END;
/

or

select utl_raw.cast_to_varchar2(utl_encode.base64_encode(utl_raw.cast_to_raw('Testuser:verySecret')))
  from dual;
/

in JQuery, aren't we missing the 'Basic ' prefix?

+1