Sweden-Number/dlls/crypt32/tests/base64.c

461 lines
19 KiB
C

/*
* Unit test suite for crypt32.dll's CryptStringToBinary and CryptBinaryToString
* functions.
*
* Copyright 2006 Juan Lang
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdio.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winerror.h>
#include <wincrypt.h>
#include "wine/test.h"
#define CERT_HEADER "-----BEGIN CERTIFICATE-----\r\n"
#define CERT_TRAILER "-----END CERTIFICATE-----\r\n"
#define CERT_REQUEST_HEADER "-----BEGIN NEW CERTIFICATE REQUEST-----\r\n"
#define CERT_REQUEST_TRAILER "-----END NEW CERTIFICATE REQUEST-----\r\n"
#define X509_HEADER "-----BEGIN X509 CRL-----\r\n"
#define X509_TRAILER "-----END X509 CRL-----\r\n"
#define CERT_HEADER_NOCR "-----BEGIN CERTIFICATE-----\n"
#define CERT_TRAILER_NOCR "-----END CERTIFICATE-----\n"
#define CERT_REQUEST_HEADER_NOCR "-----BEGIN NEW CERTIFICATE REQUEST-----\n"
#define CERT_REQUEST_TRAILER_NOCR "-----END NEW CERTIFICATE REQUEST-----\n"
#define X509_HEADER_NOCR "-----BEGIN X509 CRL-----\n"
#define X509_TRAILER_NOCR "-----END X509 CRL-----\n"
typedef BOOL (WINAPI *CryptBinaryToStringAFunc)(const BYTE *pbBinary,
DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
typedef BOOL (WINAPI *CryptStringToBinaryAFunc)(LPCSTR pszString,
DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
DWORD *pdwSkip, DWORD *pdwFlags);
CryptBinaryToStringAFunc pCryptBinaryToStringA;
CryptStringToBinaryAFunc pCryptStringToBinaryA;
struct BinTests
{
const BYTE *toEncode;
DWORD toEncodeLen;
const char *base64;
};
static const BYTE toEncode1[] = { 0 };
static const BYTE toEncode2[] = { 1,2 };
static const BYTE toEncode3[] = { 1,2,3 };
static const BYTE toEncode4[] =
"abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
"abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
"abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
struct BinTests tests[] = {
{ toEncode1, sizeof(toEncode1), "AA==\r\n", },
{ toEncode2, sizeof(toEncode2), "AQI=\r\n", },
{ toEncode3, sizeof(toEncode3), "AQID\r\n", },
{ toEncode4, sizeof(toEncode4),
"YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\r\n"
"TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\r\n"
"d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\r\n"
"Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\r\n"
"SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\r\n" },
};
struct BinTests testsNoCR[] = {
{ toEncode1, sizeof(toEncode1), "AA==\n", },
{ toEncode2, sizeof(toEncode2), "AQI=\n", },
{ toEncode3, sizeof(toEncode3), "AQID\n", },
{ toEncode4, sizeof(toEncode4),
"YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\n"
"TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\n"
"d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\n"
"Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\n"
"SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\n" },
};
static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen,
DWORD format, const char *expected, const char *header, const char *trailer)
{
DWORD strLen = 0;
LPSTR str = NULL;
BOOL ret;
ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen);
ok(ret, "CryptBinaryToStringA failed: %ld\n", GetLastError());
str = HeapAlloc(GetProcessHeap(), 0, strLen);
if (str)
{
DWORD strLen2 = strLen;
LPCSTR ptr = str;
ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, str,
&strLen2);
ok(ret, "CryptBinaryToStringA failed: %ld\n", GetLastError());
ok(strLen2 == strLen - 1, "Expected length %ld, got %ld\n",
strLen - 1, strLen);
if (header)
{
ok(!strncmp(header, ptr, strlen(header)),
"Expected header %s, got %s\n", header, ptr);
ptr += strlen(header);
}
ok(!strncmp(expected, ptr, strlen(expected)),
"Expected %s, got %s\n", expected, ptr);
ptr += strlen(expected);
if (trailer)
{
ok(!strncmp(trailer, ptr, strlen(trailer)),
"Expected trailer %s, got %s\n", trailer, ptr);
ptr += strlen(trailer);
}
HeapFree(GetProcessHeap(), 0, str);
}
}
static void testBinaryToStringA(void)
{
BOOL ret;
DWORD strLen = 0, i;
if (!pCryptBinaryToStringA) return;
ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, NULL);
ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, &strLen);
ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
{
DWORD strLen = 0;
LPSTR str = NULL;
BOOL ret;
ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BINARY, NULL, &strLen);
ok(ret, "CryptBinaryToStringA failed: %ld\n", GetLastError());
str = HeapAlloc(GetProcessHeap(), 0, strLen);
if (str)
{
DWORD strLen2 = strLen;
ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BINARY, str, &strLen2);
ok(strLen == strLen2, "Expected length %ld, got %ld\n", strLen,
strLen2);
ok(!memcmp(str, tests[i].toEncode, tests[i].toEncodeLen),
"Unexpected value\n");
HeapFree(GetProcessHeap(), 0, str);
}
encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BASE64, tests[i].base64, NULL, NULL);
encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BASE64HEADER, tests[i].base64, CERT_HEADER,
CERT_TRAILER);
encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BASE64REQUESTHEADER, tests[i].base64,
CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER);
encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
CRYPT_STRING_BASE64X509CRLHEADER, tests[i].base64, X509_HEADER,
X509_TRAILER);
}
for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
{
DWORD strLen = 0;
LPSTR str = NULL;
BOOL ret;
ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
NULL, &strLen);
ok(ret, "CryptBinaryToStringA failed: %ld\n", GetLastError());
str = HeapAlloc(GetProcessHeap(), 0, strLen);
if (str)
{
DWORD strLen2 = strLen;
ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
str, &strLen2);
ok(strLen == strLen2, "Expected length %ld, got %ld\n", strLen,
strLen2);
ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen),
"Unexpected value\n");
HeapFree(GetProcessHeap(), 0, str);
}
encodeAndCompareBase64_A(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR,
testsNoCR[i].base64, NULL, NULL);
encodeAndCompareBase64_A(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen,
CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64,
CERT_HEADER_NOCR, CERT_TRAILER_NOCR);
encodeAndCompareBase64_A(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen,
CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR,
testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR,
CERT_REQUEST_TRAILER_NOCR);
encodeAndCompareBase64_A(testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen,
CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR,
testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR);
}
}
static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header,
LPCSTR trailer, DWORD useFormat, DWORD expectedFormat, const BYTE *expected,
DWORD expectedLen)
{
static const char garbage[] = "garbage\r\n";
LPSTR str;
DWORD len = strlen(toDecode) + strlen(garbage) + 1;
if (header)
len += strlen(header);
if (trailer)
len += strlen(trailer);
str = HeapAlloc(GetProcessHeap(), 0, len);
if (str)
{
LPBYTE buf;
DWORD bufLen = 0;
BOOL ret;
if (header)
strcpy(str, header);
else
*str = 0;
strcat(str, toDecode);
if (trailer)
strcat(str, trailer);
ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
NULL);
ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
if (buf)
{
DWORD skipped, usedFormat;
/* check as normal, make sure last two parameters are optional */
ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL,
NULL);
ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
ok(bufLen == expectedLen,
"Expected length %ld, got %ld\n", expectedLen, bufLen);
ok(!memcmp(buf, expected, bufLen), "Unexpected value\n");
/* check last two params */
ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
&skipped, &usedFormat);
ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
ok(skipped == 0, "Expected skipped 0, got %ld\n", skipped);
ok(usedFormat == expectedFormat, "Expected format %ld, got %ld\n",
expectedFormat, usedFormat);
HeapFree(GetProcessHeap(), 0, buf);
}
/* Check again, but with garbage up front */
strcpy(str, garbage);
if (header)
strcat(str, header);
strcat(str, toDecode);
if (trailer)
strcat(str, trailer);
ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
NULL);
/* expect failure with no header, and success with one */
if (header)
ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
else
ok(!ret && GetLastError() == ERROR_INVALID_DATA,
"Expected ERROR_INVALID_DATA, got %ld\n", GetLastError());
if (ret)
{
buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
if (buf)
{
DWORD skipped, usedFormat;
ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
&skipped, &usedFormat);
ok(skipped == strlen(garbage),
"Expected %d characters skipped, got %ld\n", strlen(garbage),
skipped);
HeapFree(GetProcessHeap(), 0, buf);
}
}
HeapFree(GetProcessHeap(), 0, str);
}
}
struct BadString
{
const char *str;
DWORD format;
};
struct BadString badStrings[] = {
{ "A\r\nA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
{ "AA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
{ "AA=\r\n=\r\n", CRYPT_STRING_BASE64 },
{ "-----BEGIN X509 CRL-----\r\nAA==\r\n", CRYPT_STRING_BASE64X509CRLHEADER },
};
static void testStringToBinaryA(void)
{
BOOL ret;
DWORD bufLen = 0, i;
if (!pCryptStringToBinaryA) return;
ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, NULL, NULL, NULL);
ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, &bufLen, NULL, NULL);
ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
/* Bogus format */
ret = pCryptStringToBinaryA(tests[0].base64, 0, 0, NULL, &bufLen, NULL,
NULL);
ok(!ret && GetLastError() == ERROR_INVALID_DATA,
"Expected ERROR_INVALID_DATA, got %ld\n", GetLastError());
/* Decoding doesn't expect the NOCR flag to be specified */
ret = pCryptStringToBinaryA(tests[0].base64, 1,
CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, NULL, &bufLen, NULL, NULL);
ok(!ret && GetLastError() == ERROR_INVALID_DATA,
"Expected ERROR_INVALID_DATA, got %ld\n", GetLastError());
/* Bad strings */
for (i = 0; i < sizeof(badStrings) / sizeof(badStrings[0]); i++)
{
bufLen = 0;
ret = pCryptStringToBinaryA(badStrings[i].str, 0, badStrings[i].format,
NULL, &bufLen, NULL, NULL);
ok(!ret && GetLastError() == ERROR_INVALID_DATA,
"Expected ERROR_INVALID_DATA, got %ld\n", GetLastError());
}
/* Good strings */
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
{
bufLen = 0;
/* Bogus length--oddly enough, that succeeds, even though it's not
* properly padded.
*/
ret = pCryptStringToBinaryA(tests[i].base64, 1, CRYPT_STRING_BASE64,
NULL, &bufLen, NULL, NULL);
todo_wine ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
/* Check with the precise format */
decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, tests[i].toEncode,
tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
tests[i].toEncode, tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
tests[i].toEncode, tests[i].toEncodeLen);
/* And check with the "any" formats */
decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, tests[i].toEncode,
tests[i].toEncodeLen);
/* Don't check with no header and the string_any format, that'll
* always succeed.
*/
decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
tests[i].toEncodeLen);
/* oddly, these seem to decode using the wrong format
decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64_ANY,
CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
CERT_REQUEST_TRAILER, CRYPT_STRING_ANY,
CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64X509CRLHEADER,
tests[i].toEncode, tests[i].toEncodeLen);
decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
CRYPT_STRING_ANY, CRYPT_STRING_BASE64X509CRLHEADER, tests[i].toEncode,
tests[i].toEncodeLen);
*/
}
/* And again, with no CR--decoding handles this automatically */
for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
{
bufLen = 0;
/* Bogus length--oddly enough, that succeeds, even though it's not
* properly padded.
*/
ret = pCryptStringToBinaryA(testsNoCR[i].base64, 1, CRYPT_STRING_BASE64,
NULL, &bufLen, NULL, NULL);
todo_wine ok(ret, "CryptStringToBinaryA failed: %ld\n", GetLastError());
/* Check with the precise format */
decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen);
decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_REQUEST_HEADER,
CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
CRYPT_STRING_BASE64REQUESTHEADER, testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen);
decodeAndCompareBase64_A(testsNoCR[i].base64, X509_HEADER, X509_TRAILER,
CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
/* And check with the "any" formats */
decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen);
/* Don't check with no header and the string_any format, that'll
* always succeed.
*/
decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER,
testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, testsNoCR[i].toEncode,
testsNoCR[i].toEncodeLen);
}
}
START_TEST(base64)
{
HMODULE lib = LoadLibraryA("crypt32");
if (lib)
{
pCryptBinaryToStringA = (CryptBinaryToStringAFunc)GetProcAddress(lib,
"CryptBinaryToStringA");
pCryptStringToBinaryA = (CryptStringToBinaryAFunc)GetProcAddress(lib,
"CryptStringToBinaryA");
testBinaryToStringA();
testStringToBinaryA();
FreeLibrary(lib);
}
}