这个问题竟然花了三天才解决，主要是对ONVIF不太熟悉，下面分享下我解决问题的办法。
首先用gsoap生成ONVIF框架，网上例子很多，在此不多讲，可以参见 Onvif开发之代码框架生成篇 ，有一点要注意下，网上的很多例子讲的是Client端的，不是Server端，在最后使用soapcpp2 命令的时候， 不要加-C就可以生成Server端的代码。
如果是碰到 soap_get___tad__GetServiceCapabilities 之类的undefine呢， 如果不需要的话， 就直接注释吧。
现在我们以这个__tds__GetServices接口为例（在soapServer.c中有被调用），首先需要实现这个接口，然后在我们判断是否有wsse_Security
if (soap == NULL || soap->header == NULL || soap->header->wsse__Security == NULL)
{
printf ("no authentication,refuse it!\n");
return SOAP_FAULT;
}
我们要用到这些值
_wsse__Security *pwsse = soap->header->wsse__Security;
struct _wsse__UsernameToken* ptoken = pwsse->UsernameToken;
printf ("Username=%s\n", ptoken->Username);
printf ("Nonce=%s\n", ptoken->Nonce);
printf ("Password=%s\n", ptoken->Password->__item);
printf ("PasswordType=%s\n", ptoken->Password->Type);
printf ("wsu__Created=%s\n", ptoken->wsu__Created);
现在我们来看下官方的文档 ONVIF Guide 的第35页。
如图：
For example:
Nonce – LKqI6G/AikKCQrN0zqZFlg==
Date – 2010-09-16T07:50:45Z
Password – userpassword
Resulting Digest – tuOSpGlFlIXsozq4HFNeeGeFLEI=
那现在就简单了， 我们可以拿到Nonce,Date(wsu__Created)， Password(Password->__item)
现在只要按照官方给的计算方法计算出来的Digest与Password比较下就行了， 如果一样， 那就鉴权成功。
之前我是用的站长工具计算的，死活不同， 后来才意识到，是先要把Nonce给Decode，不是Encode，而且SHA1值是二进制，不是字符串。
这个鉴权方法有点问题， 就是没有判断Nonce，会有漏洞，不过由于RTSP也有鉴权，问题不算严重
这个方法的好处是没有用openssl，省了不少空间
这篇文章对我也有帮助 基于gsaop实现onvif之二 .用户验证
下面是base64和sha1的代码，用的时候看下LICENSE哈
base64.h
#ifndef __BASE64_H__
#define __BASE64_H__
int Base64decode_len(const char *bufcoded);
int Base64decode(char *bufplain, const char *bufcoded);
int Base64encode_len(int len);
int Base64encode(char *encoded, const char *string, int len);
#endif
base64.c
/*
* Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
*
* @[email protected]
*
* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @[email protected]
*/
/* ====================================================================
* Copyright (c) 1995-1999 The Apache Group. 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.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the Apache Group
* for use in the Apache HTTP server project (http://www.apache.org/)."
*
* 4. The names "Apache Server" and "Apache Group" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* [email protected]
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the Apache Group
* for use in the Apache HTTP server project (http://www.apache.org/)."
*
* THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
* EXPRESSED 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 APACHE GROUP OR
* ITS 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 software consists of voluntary contributions made by many
* individuals on behalf of the Apache Group and was originally based
* on public domain software written at the National Center for
* Supercomputing Applications, University of Illinois, Urbana-Champaign.
* For more information on the Apache Group and the Apache HTTP server
* project, please see <http://www.apache.org/>.
*
*/
/* Base64 encoder/decoder. Originally Apache file ap_base64.c
*/
#include <string.h>
#include "base64.h"
/* aaaack but it's fast and const should make it shared text page. */
static const unsigned char pr2six[] =
{
/* ASCII table */
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , , ,
, , , , , , , , , , , , , , ,
};
int Base64decode_len(const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
register int nprbytes;
bufin = (const unsigned char *) bufcoded;
while (pr2six[*(bufin++)] <= );
nprbytes = (bufin - (const unsigned char *) bufcoded) - ;
nbytesdecoded = ((nprbytes + ) / ) * ;
return nbytesdecoded + ;
}
int Base64decode(char *bufplain, const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
register unsigned char *bufout;
register int nprbytes;
bufin = (const unsigned char *) bufcoded;
while (pr2six[*(bufin++)] <= );
nprbytes = (bufin - (const unsigned char *) bufcoded) - ;
nbytesdecoded = ((nprbytes + ) / ) * ;
bufout = (unsigned char *) bufplain;
bufin = (const unsigned char *) bufcoded;
while (nprbytes > ) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << | pr2six[bufin[]] >> );
*(bufout++) =
(unsigned char) (pr2six[bufin[]] << | pr2six[bufin[]] >> );
*(bufout++) =
(unsigned char) (pr2six[bufin[]] << | pr2six[bufin[]]);
bufin += ;
nprbytes -= ;
}
/* Note: (nprbytes == 1) would be an error, so just ingore that case */
if (nprbytes > ) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << | pr2six[bufin[]] >> );
}
if (nprbytes > ) {
*(bufout++) =
(unsigned char) (pr2six[bufin[]] << | pr2six[bufin[]] >> );
}
if (nprbytes > ) {
*(bufout++) =
(unsigned char) (pr2six[bufin[]] << | pr2six[bufin[]]);
}
*(bufout++) = '\0';
nbytesdecoded -= ( - nprbytes) & ;
return nbytesdecoded;
}
static const char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int Base64encode_len(int len)
{
return ((len + ) / * ) + ;
}
int Base64encode(char *encoded, const char *string, int len)
{
int i;
char *p;
p = encoded;
for (i = ; i < len - ; i += ) {
*p++ = basis_64[(string[i] >> ) & ];
*p++ = basis_64[((string[i] & ) << ) |
((int) (string[i + ] & ) >> )];
*p++ = basis_64[((string[i + ] & ) << ) |
((int) (string[i + ] & ) >> )];
*p++ = basis_64[string[i + ] & ];
}
if (i < len) {
*p++ = basis_64[(string[i] >> ) & ];
if (i == (len - )) {
*p++ = basis_64[((string[i] & ) << )];
*p++ = '=';
}
else {
*p++ = basis_64[((string[i] & ) << ) |
((int) (string[i + ] & ) >> )];
*p++ = basis_64[((string[i + ] & ) << )];
}
*p++ = '=';
}
*p++ = '\0';
return p - encoded;
}
sha1.h
/* Declarations of functions and data types used for SHA1 sum
library functions.
Copyright (C) , , , , , ,
Free Software Foundation, Inc.
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 , 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., Franklin Street, Fifth Floor, Boston, MA -, USA. */
#ifndef SHA1_H
# define SHA1_H 1
#include <stdio.h>
#if defined HAVE_LIMITS_H || _LIBC
# include <limits.h>
#endif
/* The following contortions are an attempt to use the C preprocessor
to determine an unsigned integral type that is bits wide. An
alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
doing that would require that the configure script compile and *run*
the resulting executable. Locally running cross-compiled executables
is usually not possible. */
#ifdef _LIBC
# include <sys/types.h>
typedef u_int32_t sha1_uint32;
typedef uintptr_t sha1_uintptr;
#elif defined (HAVE_SYS_TYPES_H) && defined (HAVE_STDINT_H)
#include <stdint.h>
#include <sys/types.h>
typedef uint32_t sha1_uint32;
typedef uintptr_t sha1_uintptr;
#else
# define INT_MAX_32_BITS 2147483647
/* If UINT_MAX isn't defined, assume it's a -bit type.
This should be valid for all systems GNU cares about because
that doesn't include -bit systems, and only modern systems
(that certainly have <limits.h>) have +-bit integral types. */
# ifndef INT_MAX
# define INT_MAX INT_MAX_32_BITS
# endif
# if INT_MAX == INT_MAX_32_BITS
typedef unsigned int sha1_uint32;
# else
# if SHRT_MAX == INT_MAX_32_BITS
typedef unsigned short sha1_uint32;
# else
# if LONG_MAX == INT_MAX_32_BITS
typedef unsigned long sha1_uint32;
# else
/* The following line is intended to evoke an error.
Using #error is not portable enough. */
"Cannot determine unsigned 32-bit data type."
# endif
# endif
# endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Structure to save state of computation between the single steps. */
struct sha1_ctx
{
sha1_uint32 A;
sha1_uint32 B;
sha1_uint32 C;
sha1_uint32 D;
sha1_uint32 E;
sha1_uint32 total[];
sha1_uint32 buflen;
sha1_uint32 buffer[];
};
/* Initialize structure containing state of computation. */
extern void sha1_init_ctx (struct sha1_ctx *ctx);
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is necessary that LEN is a multiple of !!! */
extern void sha1_process_block (const void *buffer, size_t len,
struct sha1_ctx *ctx);
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is NOT required that LEN is a multiple of */
extern void sha1_process_bytes (const void *buffer, size_t len,
struct sha1_ctx *ctx);
/* Process the remaining bytes in the buffer and put result from CTX
in first bytes following RESBUF. The result is always in little
endian byte order, so that a byte-wise output yields to the wanted
ASCII representation of the message digest.
IMPORTANT: On some systems it is required that RESBUF be correctly
aligned for a bits value. */
extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
/* Put result from CTX in first bytes following RESBUF. The result is
always in little endian byte order, so that a byte-wise output yields
to the wanted ASCII representation of the message digest.
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a bits value. */
extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf);
/* Compute SHA1 message digest for bytes read from STREAM. The
resulting message digest number will be written into the bytes
beginning at RESBLOCK. */
extern int sha1_stream (FILE *stream, void *resblock);
/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
extern void *sha1_buffer (const char *buffer, size_t len, void *resblock);
#ifdef __cplusplus
}
#endif
#endif
sha1.c
/* sha1.c - Functions to compute SHA1 message digest of files or
memory blocks according to the NIST specification FIPS--
Copyright (C) , , , , , , Free Software
Foundation, Inc.
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 , 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., Franklin Street, Fifth Floor, Boston, MA -, USA. */
/* Written by Scott G. Miller
Credits:
Robert Klep <[email protected]> -- Expansion function fix
*/
#include "sha1.h"
#include <stddef.h>
#include <string.h>
#if USE_UNLOCKED_IO
# include "unlocked-io.h"
#endif
#ifdef WORDS_BIGENDIAN
# define SWAP(n) (n)
#else
# define SWAP(n) \
(((n) << ) | (((n) & ) << ) | (((n) >> ) & ) | ((n) >> ))
#endif
#define BLOCKSIZE 4096
#if BLOCKSIZE % 64 != 0
# error "invalid BLOCKSIZE"
#endif
/* This array contains the bytes used to pad the buffer to the next
-byte boundary. (RFC , : Step ) */
static const unsigned char fillbuf[] = { , /* , , , ... */ };
/* Take a pointer to a bit block of data (five bit ints) and
initialize it to the start constants of the SHA1 algorithm. This
must be called before using hash in the call to sha1_hash. */
void
sha1_init_ctx (struct sha1_ctx *ctx)
{
ctx->A = ;
ctx->B = ;
ctx->C = ;
ctx->D = ;
ctx->E = ;
ctx->total[] = ctx->total[] = ;
ctx->buflen = ;
}
/* Put result from CTX in first bytes following RESBUF. The result
must be in little endian byte order.
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a -bit value. */
void *
sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
{
((sha1_uint32 *) resbuf)[] = SWAP (ctx->A);
((sha1_uint32 *) resbuf)[] = SWAP (ctx->B);
((sha1_uint32 *) resbuf)[] = SWAP (ctx->C);
((sha1_uint32 *) resbuf)[] = SWAP (ctx->D);
((sha1_uint32 *) resbuf)[] = SWAP (ctx->E);
return resbuf;
}
/* Process the remaining bytes in the internal buffer and the usual
prolog according to the standard and write the result to RESBUF.
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a -bit value. */
void *
sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
sha1_uint32 bytes = ctx->buflen;
size_t size = (bytes < ) ? / : * / ;
/* Now count remaining bytes. */
ctx->total[] += bytes;
if (ctx->total[] < bytes)
++ctx->total[];
/* Put the -bit file length in *bits* at the end of the buffer. */
ctx->buffer[size - ] = SWAP ((ctx->total[] << ) | (ctx->total[] >> ));
ctx->buffer[size - ] = SWAP (ctx->total[] << );
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - ) * - bytes);
/* Process last bytes. */
sha1_process_block (ctx->buffer, size * , ctx);
return sha1_read_ctx (ctx, resbuf);
}
/* Compute SHA1 message digest for bytes read from STREAM. The
resulting message digest number will be written into the bytes
beginning at RESBLOCK. */
int
sha1_stream (FILE *stream, void *resblock)
{
struct sha1_ctx ctx;
char buffer[BLOCKSIZE + ];
size_t sum;
/* Initialize the computation context. */
sha1_init_ctx (&ctx);
/* Iterate over full file contents. */
while ()
{
/* We read the file in blocks of BLOCKSIZE bytes. One call of the
computation function processes the whole buffer so that with the
next round of the loop another block can be read. */
size_t n;
sum = ;
/* Read block. Take care for partial reads. */
while ()
{
n = fread (buffer + sum, , BLOCKSIZE - sum, stream);
sum += n;
if (sum == BLOCKSIZE)
break;
if (n == )
{
/* Check for the error flag IFF N == , so that we don't
exit the loop after a partial read due to e.g., EAGAIN
or EWOULDBLOCK. */
if (ferror (stream))
return ;
goto process_partial_block;
}
/* We've read at least one byte, so ignore errors. But always
check for EOF, since feof may be true even though N >
Otherwise, we could end up calling fread after EOF. */
if (feof (stream))
goto process_partial_block;
}
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % ==
*/
sha1_process_block (buffer, BLOCKSIZE, &ctx);
}
process_partial_block:;
/* Process any remaining bytes. */
if (sum > )
sha1_process_bytes (buffer, sum, &ctx);
/* Construct result in desired memory. */
sha1_finish_ctx (&ctx, resblock);
return ;
}
/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
void *
sha1_buffer (const char *buffer, size_t len, void *resblock)
{
struct sha1_ctx ctx;
/* Initialize the computation context. */
sha1_init_ctx (&ctx);
/* Process whole buffer but last len % bytes. */
sha1_process_bytes (buffer, len, &ctx);
/* Put result in desired memory area. */
return sha1_finish_ctx (&ctx, resblock);
}
void
sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
{
/* When we already have some bits in our internal buffer concatenate
both inputs first. */
if (ctx->buflen != )
{
size_t left_over = ctx->buflen;
size_t add = - left_over > len ? len : - left_over;
memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
ctx->buflen += add;
if (ctx->buflen > )
{
sha1_process_block (ctx->buffer, ctx->buflen & ~, ctx);
ctx->buflen &= ;
/* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer,
&((char *) ctx->buffer)[(left_over + add) & ~],
ctx->buflen);
}
buffer = (const char *) buffer + add;
len -= add;
}
/* Process available complete blocks. */
if (len >= )
{
#if !_STRING_ARCH_unaligned
# define alignof(type) offsetof (struct { char c; type x; }, x)
# define UNALIGNED_P(p) (((size_t) p) % alignof (sha1_uint32) != 0)
if (UNALIGNED_P (buffer))
while (len > )
{
sha1_process_block (memcpy (ctx->buffer, buffer, ), , ctx);
buffer = (const char *) buffer + ;
len -= ;
}
else
#endif
{
sha1_process_block (buffer, len & ~, ctx);
buffer = (const char *) buffer + (len & ~);
len &= ;
}
}
/* Move remaining bytes in internal buffer. */
if (len > )
{
size_t left_over = ctx->buflen;
memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
left_over += len;
if (left_over >= )
{
sha1_process_block (ctx->buffer, , ctx);
left_over -= ;
memcpy (ctx->buffer, &ctx->buffer[], left_over);
}
ctx->buflen = left_over;
}
}
/* --- Code below is the primary difference between md5.c and sha1.c --- */
/* SHA1 round constants */
#define K1 0x5a827999
#define K2 0x6ed9eba1
#define K3 0x8f1bbcdc
#define K4 0xca62c1d6
/* Round functions. Note that F2 is the same as F4. */
#define F1(B,C,D) ( D ^ ( B & ( C ^ D ) ) )
#define F2(B,C,D) (B ^ C ^ D)
#define F3(B,C,D) ( ( B & C ) | ( D & ( B | C ) ) )
#define F4(B,C,D) (B ^ C ^ D)
/* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % ==
Most of this code comes from GnuPG's cipher/sha1.c. */
void
sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx)
{
const sha1_uint32 *words = (const sha1_uint32*) buffer;
size_t nwords = len / sizeof (sha1_uint32);
const sha1_uint32 *endp = words + nwords;
sha1_uint32 x[];
sha1_uint32 a = ctx->A;
sha1_uint32 b = ctx->B;
sha1_uint32 c = ctx->C;
sha1_uint32 d = ctx->D;
sha1_uint32 e = ctx->E;
/* First increment the byte count. RFC specifies the possible
length of the file up to ^ bits. Here we only compute the
number of bytes. Do a double word increment. */
ctx->total[] += len;
ctx->total[] += ((len >> ) >> ) + (ctx->total[] < len);
#define rol(x, n) (((x) << (n)) | ((sha1_uint32) (x) >> (32 - (n))))
#define M(I) ( tm = x[I&0x0f] ^ x[(I-14)&0x0f] \
^ x[(I-)&] ^ x[(I-)&] \
, (x[I&] = rol(tm, )) )
#define R(A,B,C,D,E,F,K,M) do { E += rol( A, 5 ) \
+ F( B, C, D ) \
+ K \
+ M; \
B = rol( B, ); \
} while()
while (words < endp)
{
sha1_uint32 tm;
int t;
for (t = ; t < ; t++)
{
x[t] = SWAP (*words);
words++;
}
R( a, b, c, d, e, F1, K1, x[ 0] );
R( e, a, b, c, d, F1, K1, x[ 1] );
R( d, e, a, b, c, F1, K1, x[ 2] );
R( c, d, e, a, b, F1, K1, x[ 3] );
R( b, c, d, e, a, F1, K1, x[ 4] );
R( a, b, c, d, e, F1, K1, x[ 5] );
R( e, a, b, c, d, F1, K1, x[ 6] );
R( d, e, a, b, c, F1, K1, x[ 7] );
R( c, d, e, a, b, F1, K1, x[ 8] );
R( b, c, d, e, a, F1, K1, x[ 9] );
R( a, b, c, d, e, F1, K1, x[10] );
R( e, a, b, c, d, F1, K1, x[11] );
R( d, e, a, b, c, F1, K1, x[12] );
R( c, d, e, a, b, F1, K1, x[13] );
R( b, c, d, e, a, F1, K1, x[14] );
R( a, b, c, d, e, F1, K1, x[15] );
R( e, a, b, c, d, F1, K1, M(16) );
R( d, e, a, b, c, F1, K1, M(17) );
R( c, d, e, a, b, F1, K1, M(18) );
R( b, c, d, e, a, F1, K1, M(19) );
R( a, b, c, d, e, F2, K2, M(20) );
R( e, a, b, c, d, F2, K2, M(21) );
R( d, e, a, b, c, F2, K2, M(22) );
R( c, d, e, a, b, F2, K2, M(23) );
R( b, c, d, e, a, F2, K2, M(24) );
R( a, b, c, d, e, F2, K2, M(25) );
R( e, a, b, c, d, F2, K2, M(26) );
R( d, e, a, b, c, F2, K2, M(27) );
R( c, d, e, a, b, F2, K2, M(28) );
R( b, c, d, e, a, F2, K2, M(29) );
R( a, b, c, d, e, F2, K2, M(30) );
R( e, a, b, c, d, F2, K2, M(31) );
R( d, e, a, b, c, F2, K2, M(32) );
R( c, d, e, a, b, F2, K2, M(33) );
R( b, c, d, e, a, F2, K2, M(34) );
R( a, b, c, d, e, F2, K2, M(35) );
R( e, a, b, c, d, F2, K2, M(36) );
R( d, e, a, b, c, F2, K2, M(37) );
R( c, d, e, a, b, F2, K2, M(38) );
R( b, c, d, e, a, F2, K2, M(39) );
R( a, b, c, d, e, F3, K3, M(40) );
R( e, a, b, c, d, F3, K3, M(41) );
R( d, e, a, b, c, F3, K3, M(42) );
R( c, d, e, a, b, F3, K3, M(43) );
R( b, c, d, e, a, F3, K3, M(44) );
R( a, b, c, d, e, F3, K3, M(45) );
R( e, a, b, c, d, F3, K3, M(46) );
R( d, e, a, b, c, F3, K3, M(47) );
R( c, d, e, a, b, F3, K3, M(48) );
R( b, c, d, e, a, F3, K3, M(49) );
R( a, b, c, d, e, F3, K3, M(50) );
R( e, a, b, c, d, F3, K3, M(51) );
R( d, e, a, b, c, F3, K3, M(52) );
R( c, d, e, a, b, F3, K3, M(53) );
R( b, c, d, e, a, F3, K3, M(54) );
R( a, b, c, d, e, F3, K3, M(55) );
R( e, a, b, c, d, F3, K3, M(56) );
R( d, e, a, b, c, F3, K3, M(57) );
R( c, d, e, a, b, F3, K3, M(58) );
R( b, c, d, e, a, F3, K3, M(59) );
R( a, b, c, d, e, F4, K4, M(60) );
R( e, a, b, c, d, F4, K4, M(61) );
R( d, e, a, b, c, F4, K4, M(62) );
R( c, d, e, a, b, F4, K4, M(63) );
R( b, c, d, e, a, F4, K4, M(64) );
R( a, b, c, d, e, F4, K4, M(65) );
R( e, a, b, c, d, F4, K4, M(66) );
R( d, e, a, b, c, F4, K4, M(67) );
R( c, d, e, a, b, F4, K4, M(68) );
R( b, c, d, e, a, F4, K4, M(69) );
R( a, b, c, d, e, F4, K4, M(70) );
R( e, a, b, c, d, F4, K4, M(71) );
R( d, e, a, b, c, F4, K4, M(72) );
R( c, d, e, a, b, F4, K4, M(73) );
R( b, c, d, e, a, F4, K4, M(74) );
R( a, b, c, d, e, F4, K4, M(75) );
R( e, a, b, c, d, F4, K4, M(76) );
R( d, e, a, b, c, F4, K4, M(77) );
R( c, d, e, a, b, F4, K4, M(78) );
R( b, c, d, e, a, F4, K4, M(79) );
a = ctx->A += a;
b = ctx->B += b;
c = ctx->C += c;
d = ctx->D += d;
e = ctx->E += e;
}
}
//Digest = B64ENCODE( SHA1( B64DECODE( Nonce ) + Date + Password ) )
//see : https://www.onvif.org/wp-content/uploads/2016/12/ONVIF_WG-APG-Application_Programmers_Guide-1.pdf
static int digest_auth_info (const char *usrpwd, const char *nonce_coded, const char *date, char *digest_buff, int buffsize)
{
char nonce[] = {};
int nonce_len = ;
unsigned char sha1_code[] = {};
//B64DECODE( Nonce )
nonce_len = Base64decode (nonce, nonce_coded);//decode nonce
printf ("nonce:\n");
pri_pkg (nonce, nonce_len);
//SHA1( B64DECODE( Nonce ) + Date + Password )
struct sha1_ctx sha1;
sha1_init_ctx (&sha1);
sha1_process_bytes (nonce, nonce_len, &sha1);
sha1_process_bytes (date, strlen (date), &sha1);
sha1_process_bytes (usrpwd, strlen (usrpwd), &sha1);
sha1_finish_ctx (&sha1, sha1_code);
printf ("sha1:\n");
pri_pkg (sha1_code, );
//B64ENCODE( SHA1( B64DECODE( Nonce ) + Date + Password ) )
Base64encode (digest_buff, sha1_code, );
return ;
}
![linux-svn卸载与安装[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)