Index: src/pbkdf2.h
==================================================================
--- src/pbkdf2.h
+++ src/pbkdf2.h
@@ -27,13 +27,13 @@
 /** @file */
 
 @class OFHMAC;
 
 /**
- * @brief The parameters for @ref of_pbkdf2.
+ * @brief The parameters for @ref OFPBKDF2.
  */
-typedef struct of_pbkdf2_parameters_t {
+typedef struct OFPBKDF2Parameters {
 	/** @brief The HMAC to use to derive a key. */
 	__unsafe_unretained OFHMAC *HMAC;
 	/** @brief The number of iterations to perform. */
 	size_t iterations;
 	/** @brief The salt to derive a key with. */
@@ -52,11 +52,11 @@
 	 * @ref key needs to have enough storage.
 	 */
 	size_t keyLength;
 	/** @brief Whether data may be stored in swappable memory. */
 	bool allowsSwappableMemory;
-} of_pbkdf2_parameters_t;
+} OFPBKDF2Parameters;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 /**
@@ -66,11 +66,11 @@
  *	 possible to reuse the `HMAC`, but also meaning all previous results
  *	 from the `HMAC` get invalidated if they have not been copied.
  *
  * @param param The parameters to use
  */
-extern void of_pbkdf2(of_pbkdf2_parameters_t param);
+extern void OFPBKDF2(OFPBKDF2Parameters param);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/pbkdf2.m
==================================================================
--- src/pbkdf2.m
+++ src/pbkdf2.m
@@ -25,11 +25,11 @@
 #import "OFOutOfRangeException.h"
 
 #import "pbkdf2.h"
 
 void
-of_pbkdf2(of_pbkdf2_parameters_t param)
+OFPBKDF2(OFPBKDF2Parameters param)
 {
 	void *pool = objc_autoreleasePoolPush();
 	size_t blocks, digestSize = param.HMAC.digestSize;
 	OFSecureData *buffer = [OFSecureData
 		    dataWithCount: digestSize

Index: src/scrypt.m
==================================================================
--- src/scrypt.m
+++ src/scrypt.m
@@ -180,11 +180,11 @@
 
 		HMAC = [[OFHMAC alloc]
 			initWithHashClass: [OFSHA256Hash class]
 		    allowsSwappableMemory: param.allowsSwappableMemory];
 
-		of_pbkdf2((of_pbkdf2_parameters_t){
+		OFPBKDF2((OFPBKDF2Parameters){
 			.HMAC                  = HMAC,
 			.iterations            = 1,
 			.salt                  = param.salt,
 			.saltLength            = param.saltLength,
 			.password              = param.password,
@@ -197,11 +197,11 @@
 
 		for (size_t i = 0; i < param.parallelization; i++)
 			of_scrypt_romix(bufferItems + i * 32 * param.blockSize,
 			    param.blockSize, param.costFactor, tmpItems);
 
-		of_pbkdf2((of_pbkdf2_parameters_t){
+		OFPBKDF2((OFPBKDF2Parameters){
 			.HMAC                  = HMAC,
 			.iterations            = 1,
 			.salt                  = (unsigned char *)bufferItems,
 			.saltLength            = param.parallelization * 128 *
 			                         param.blockSize,

Index: tests/PBKDF2Tests.m
==================================================================
--- tests/PBKDF2Tests.m
+++ tests/PBKDF2Tests.m
@@ -30,11 +30,11 @@
 	unsigned char key[25];
 
 	/* Test vectors from RFC 6070 */
 
 	TEST(@"PBKDF2-SHA1, 1 iteration",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 1,
 		.salt                  = (unsigned char *)"salt",
 		.saltLength            = 4,
 		.password              = "password",
@@ -44,11 +44,11 @@
 		.allowsSwappableMemory = true
 	    })) && memcmp(key, "\x0C\x60\xC8\x0F\x96\x1F\x0E\x71\xF3\xA9\xB5"
 		"\x24\xAF\x60\x12\x06\x2F\xE0\x37\xA6", 20) == 0)
 
 	TEST(@"PBKDF2-SHA1, 2 iterations",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 2,
 		.salt                  = (unsigned char *)"salt",
 		.saltLength            = 4,
 		.password              = "password",
@@ -58,11 +58,11 @@
 		.allowsSwappableMemory = true
 	    })) && memcmp(key, "\xEA\x6C\x01\x4D\xC7\x2D\x6F\x8C\xCD\x1E\xD9"
 	        "\x2A\xCE\x1D\x41\xF0\xD8\xDE\x89\x57", 20) == 0)
 
 	TEST(@"PBKDF2-SHA1, 4096 iterations",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 4096,
 		.salt                  = (unsigned char *)"salt",
 		.saltLength            = 4,
 		.password              = "password",
@@ -74,11 +74,11 @@
 	        "\xD9\x26\xF7\x21\xD0\x65\xA4\x29\xC1", 20) == 0)
 
 	/* This test takes too long, even on a fast machine. */
 #if 0
 	TEST(@"PBKDF2-SHA1, 16777216 iterations",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 16777216,
 		.salt                  = (unsigned char *)"salt",
 		.saltLength            = 4,
 		.password              = "password",
@@ -89,11 +89,11 @@
 	    })) && memcmp(key, "\xEE\xFE\x3D\x61\xCD\x4D\xA4\xE4\xE9\x94\x5B"
 	        "\x3D\x6B\xA2\x15\x8C\x26\x34\xE9\x84", 20) == 0)
 #endif
 
 	TEST(@"PBKDF2-SHA1, 4096 iterations, key > 1 block",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 4096,
 		.salt                  = (unsigned char *)"saltSALTsaltSALTsalt"
 		                         "SALTsaltSALTsalt",
 		.saltLength            = 36,
@@ -105,11 +105,11 @@
 	    })) &&
 	    memcmp(key, "\x3D\x2E\xEC\x4F\xE4\x1C\x84\x9B\x80\xC8\xD8\x36\x62"
 	        "\xC0\xE4\x4A\x8B\x29\x1A\x96\x4C\xF2\xF0\x70\x38", 25) == 0)
 
 	TEST(@"PBKDF2-SHA1, 4096 iterations, key < 1 block",
-	    R(of_pbkdf2((of_pbkdf2_parameters_t){
+	    R(OFPBKDF2((OFPBKDF2Parameters){
 		.HMAC                  = HMAC,
 		.iterations            = 4096,
 		.salt                  = (unsigned char *)"sa\0lt",
 		.saltLength            = 5,
 		.password              = "pass\0word",