int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode) { mz_stream_split *split = (mz_stream_split *)stream; int32_t number_disk = 0; split->mode = mode; split->path_cd_size = (uint32_t)strlen(path) + 1; split->path_cd = (char *)MZ_ALLOC(split->path_cd_size); if (split->path_cd == NULL) return MZ_MEM_ERROR; strncpy(split->path_cd, path, split->path_cd_size - 1); split->path_cd[split->path_cd_size - 1] = 0; mz_stream_split_print("Split - Open - %s (disk %"PRId32")\n", split->path_cd, number_disk); split->path_disk_size = (uint32_t)strlen(path) + 10; split->path_disk = (char *)MZ_ALLOC(split->path_disk_size); if (split->path_disk == NULL) { MZ_FREE(split->path_cd); return MZ_MEM_ERROR; } strncpy(split->path_disk, path, split->path_disk_size - 1); split->path_disk[split->path_disk_size - 1] = 0; if ((mode & MZ_OPEN_MODE_WRITE) && ((mode & MZ_OPEN_MODE_APPEND) == 0)) { number_disk = 0; split->current_disk = -1; } else { number_disk = -1; split->current_disk = 0; } return mz_stream_split_goto_disk(stream, number_disk); }
void *mz_crypt_aes_create(void **handle) { mz_crypt_aes *aes = NULL; aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes)); if (aes != NULL) memset(aes, 0, sizeof(mz_crypt_aes)); if (handle != NULL) *handle = aes; return aes; }
void *mz_crypt_hmac_create(void **handle) { mz_crypt_hmac *hmac = NULL; hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac)); if (hmac != NULL) { memset(hmac, 0, sizeof(mz_crypt_hmac)); hmac->algorithm = MZ_HASH_SHA256; } if (handle != NULL) *handle = hmac; return hmac; }
void *mz_crypt_sha_create(void **handle) { mz_crypt_sha *sha = NULL; sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha)); if (sha != NULL) { memset(sha, 0, sizeof(mz_crypt_sha)); sha->algorithm = MZ_HASH_SHA256; } if (handle != NULL) *handle = sha; return sha; }
void *mz_stream_split_create(void **stream) { mz_stream_split *split = NULL; split = (mz_stream_split *)MZ_ALLOC(sizeof(mz_stream_split)); if (split != NULL) { memset(split, 0, sizeof(mz_stream_split)); split->stream.vtbl = &mz_stream_split_vtbl; } if (stream != NULL) *stream = split; return split; }
void *mz_stream_raw_create(void **stream) { mz_stream_raw *raw = NULL; raw = (mz_stream_raw *)MZ_ALLOC(sizeof(mz_stream_raw)); if (raw != NULL) { memset(raw, 0, sizeof(mz_stream_raw)); raw->stream.vtbl = &mz_stream_raw_vtbl; } if (stream != NULL) *stream = raw; return raw; }
void *mz_stream_mem_create(void **stream) { mz_stream_mem *mem = NULL; mem = (mz_stream_mem *)MZ_ALLOC(sizeof(mz_stream_mem)); if (mem != NULL) { memset(mem, 0, sizeof(mz_stream_mem)); mem->stream.vtbl = &mz_stream_mem_vtbl; mem->grow_size = 4096; } if (stream != NULL) *stream = mem; return mem; }
int32_t mz_dir_make(const char *path) { int32_t err = MZ_OK; int16_t len = 0; char *current_dir = NULL; char *match = NULL; char hold = 0; len = (int16_t)strlen(path); if (len <= 0) return 0; current_dir = (char *)MZ_ALLOC((uint16_t)len + 1); if (current_dir == NULL) return MZ_MEM_ERROR; strcpy(current_dir, path); if (current_dir[len - 1] == '/') current_dir[len - 1] = 0; err = mz_os_make_dir(current_dir); if (err != MZ_OK) { match = current_dir + 1; while (1) { while (*match != 0 && *match != '\\' && *match != '/') match += 1; hold = *match; *match = 0; err = mz_os_make_dir(current_dir); if (err != MZ_OK) break; if (hold == 0) break; *match = hold; match += 1; } } MZ_FREE(current_dir); return err; }
void *mz_stream_wzaes_create(void **stream) { mz_stream_wzaes *wzaes = NULL; wzaes = (mz_stream_wzaes *)MZ_ALLOC(sizeof(mz_stream_wzaes)); if (wzaes != NULL) { memset(wzaes, 0, sizeof(mz_stream_wzaes)); wzaes->stream.vtbl = &mz_stream_wzaes_vtbl; wzaes->encryption_mode = MZ_AES_ENCRYPTION_MODE_256; mz_crypt_hmac_create(&wzaes->hmac); mz_crypt_aes_create(&wzaes->aes); } if (stream != NULL) *stream = wzaes; return wzaes; }
static int32_t mz_stream_mem_set_size(void *stream, int32_t size) { mz_stream_mem *mem = (mz_stream_mem *)stream; int32_t new_size = size; uint8_t *new_buf = NULL; new_buf = (uint8_t *)MZ_ALLOC((uint32_t)new_size); if (new_buf == NULL) return MZ_BUF_ERROR; if (mem->buffer) { memcpy(new_buf, mem->buffer, mem->size); MZ_FREE(mem->buffer); } mem->buffer = new_buf; mem->size = new_size; return MZ_OK; }
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size, const char *cert_pwd, uint8_t **signature, int32_t *signature_size) { PKCS12 *p12 = NULL; EVP_PKEY *evp_pkey = NULL; BUF_MEM *buf_mem = NULL; BIO *cert_bio = NULL; BIO *message_bio = NULL; BIO *signature_bio = NULL; CMS_ContentInfo *cms = NULL; CMS_SignerInfo *signer_info = NULL; STACK_OF(X509) *ca_stack = NULL; X509 *cert = NULL; int32_t result = 0; int32_t err = MZ_OK; if (message == NULL || cert_data == NULL || signature == NULL || signature_size == NULL) return MZ_PARAM_ERROR; mz_crypt_init(); *signature = NULL; *signature_size = 0; cert_bio = BIO_new_mem_buf(cert_data, cert_data_size); if (d2i_PKCS12_bio(cert_bio, &p12) == NULL) err = MZ_SIGN_ERROR; if (err == MZ_OK) result = PKCS12_parse(p12, cert_pwd, &evp_pkey, &cert, &ca_stack); if (result) { cms = CMS_sign(NULL, NULL, ca_stack, NULL, CMS_BINARY | CMS_PARTIAL); if (cms) signer_info = CMS_add1_signer(cms, cert, evp_pkey, EVP_sha256(), 0); if (signer_info == NULL) { err = MZ_SIGN_ERROR; } else { message_bio = BIO_new_mem_buf(message, message_size); signature_bio = BIO_new(BIO_s_mem()); result = CMS_final(cms, message_bio, NULL, CMS_BINARY); if (result) result = i2d_CMS_bio(signature_bio, cms); if (result) { BIO_flush(signature_bio); BIO_get_mem_ptr(signature_bio, &buf_mem); *signature_size = buf_mem->length; *signature = MZ_ALLOC(buf_mem->length); memcpy(*signature, buf_mem->data, buf_mem->length); } #if 0 BIO *yy = BIO_new_file("xyz", "wb"); BIO_write(yy, *signature, *signature_size); BIO_flush(yy); BIO_free(yy); #endif } } if (!result) err = MZ_SIGN_ERROR; if (cms) CMS_ContentInfo_free(cms); if (signature_bio) BIO_free(signature_bio); if (cert_bio) BIO_free(cert_bio); if (message_bio) BIO_free(message_bio); if (p12) PKCS12_free(p12); if (err != MZ_OK && *signature != NULL) { MZ_FREE(*signature); *signature = NULL; *signature_size = 0; } return err; }
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size, const char *cert_pwd, uint8_t **signature, int32_t *signature_size) { CFStringRef password_ref = NULL; CFDictionaryRef options_dict = NULL; CFDictionaryRef identity_trust = NULL; CFDataRef signature_out = NULL; CFDataRef pkcs12_data = NULL; CFArrayRef items = 0; SecIdentityRef identity = NULL; SecTrustRef trust = NULL; OSStatus status = noErr; const void *options_key[2] = { kSecImportExportPassphrase, kSecReturnRef }; const void *options_values[2] = { 0, kCFBooleanTrue }; int32_t err = MZ_SIGN_ERROR; if (message == NULL || cert_data == NULL || signature == NULL || signature_size == NULL) return MZ_PARAM_ERROR; *signature = NULL; *signature_size = 0; password_ref = CFStringCreateWithCString(0, cert_pwd, kCFStringEncodingUTF8); options_values[0] = password_ref; options_dict = CFDictionaryCreate(0, options_key, options_values, 2, 0, 0); if (options_dict) pkcs12_data = CFDataCreate(0, cert_data, cert_data_size); if (pkcs12_data) status = SecPKCS12Import(pkcs12_data, options_dict, &items); if (status == noErr) identity_trust = CFArrayGetValueAtIndex(items, 0); if (identity_trust) identity = (SecIdentityRef)CFDictionaryGetValue(identity_trust, kSecImportItemIdentity); if (identity) trust = (SecTrustRef)CFDictionaryGetValue(identity_trust, kSecImportItemTrust); if (trust) { status = CMSEncodeContent(identity, NULL, NULL, FALSE, 0, message, message_size, &signature_out); if (status == errSecSuccess) { *signature_size = CFDataGetLength(signature_out); *signature = (uint8_t *)MZ_ALLOC(*signature_size); memcpy(*signature, CFDataGetBytePtr(signature_out), *signature_size); err = MZ_OK; } } if (signature_out) CFRelease(signature_out); if (items) CFRelease(items); if (pkcs12_data) CFRelease(pkcs12_data); if (options_dict) CFRelease(options_dict); if (password_ref) CFRelease(password_ref); return err; }