Public/elog
1
0
Fork 0
mirror of https://gitea.psi.ch/ELOG/elog.git synced 2026-09-12 19:33:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Release 2.8.0-1

Browse Source 
SVN revision: 2312
This commit is contained in:
Stefan Ritt 2010-08-02 10:13:42 +00:00
parent e68508cd8f
commit ee380ba588
21 changed files with 407 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
doc/ChangeLog
View File

@ -1,3 +1,24 @@
Version 2.8.0, released August 2nd 2010
=======================================
- Truncate command line arguments if they exceed internal string lengths
- Changed encryption method to strong encryption, thanks to Lukasz Olejnik
- Implemented SLL passphrase, although this should be deprecated
- Fixed three XSS holes, thanks to Lukasz Olejnik
- Limit text body size for RSS feed to 2k to avoid lock-up for very long entries
- Fixed JS bug with "Fix text"
- Implemented 'Enable Smileys'
- Fixed problem with cloning and "Guest menu commands = .." being present in the config file
- Added option "Cell Style <atrib> <value>"
- Fixed bug with URL in expanding groups using top groups
- Fixed stack overflow of Select -> Edit with many replies
- Increased socket timeout, show content length error correctly
- Fixed bug with quick date filter and threaded display
- Fixed problem with "'" in french translation for JavaScript
- Added 'last 3 days' option from David Pilgram
- Do no thread evaluation when doing filtering
- Fixed usage of undefine 'date' under 'subst on reply...'
Version 2.7.8, released December 2nd 2009 Version 2.7.8, released December 2nd 2009
========================================= =========================================

2
doc/index.html
View File

@ -28,7 +28,7 @@
&nbsp;[<a class="nav" href="#links">Links</a>]&nbsp; *&nbsp;</div> &nbsp;[<a class="nav" href="#links">Links</a>]&nbsp; *&nbsp;</div>
<P class="Sub">Home of the <i>Electronic Logbook</i> package by <a href="mailto:Stefan.Ritt&#64;psi.ch"> <P class="Sub">Home of the <i>Electronic Logbook</i> package by <a href="mailto:Stefan.Ritt&#64;psi.ch">
Stefan Ritt</a></P> Stefan Ritt</a></P>
<div class="version">Current version is : 2.7.8</div> <div class="version">Current version is : 2.8.0</div>
<center> <center>
<a href="http://www.softpedia.com/progClean/ELOG-Clean-30897.html"><img border="0" src="http://www.softpedia.com/images/spyward/softpedia_free_award_f.gif" alt="certificate" title="certificate" /></a> <a href="http://www.softpedia.com/progClean/ELOG-Clean-30897.html"><img border="0" src="http://www.softpedia.com/images/spyward/softpedia_free_award_f.gif" alt="certificate" title="certificate" /></a>

2
doc/index_nd.html
View File

@ -28,7 +28,7 @@
&nbsp;[<a class="nav" href="#links">Links</a>]&nbsp; *&nbsp;</div> &nbsp;[<a class="nav" href="#links">Links</a>]&nbsp; *&nbsp;</div>
<P class="Sub">Home of the <i>Electronic Logbook</i> package by <a href="mailto:Stefan.Ritt&#64;psi.ch"> <P class="Sub">Home of the <i>Electronic Logbook</i> package by <a href="mailto:Stefan.Ritt&#64;psi.ch">
Stefan Ritt</a></P> Stefan Ritt</a></P>
<div class="version">Current version is : 2.7.8</div> <div class="version">Current version is : 2.8.0</div>
<center> <center>
<a href="http://www.softpedia.com/progClean/ELOG-Clean-30897.html"><img border="0" src="http://www.softpedia.com/images/spyward/softpedia_free_award_f.gif" alt="certificate" title="certificate" /></a> <a href="http://www.softpedia.com/progClean/ELOG-Clean-30897.html"><img border="0" src="http://www.softpedia.com/images/spyward/softpedia_free_award_f.gif" alt="certificate" title="certificate" /></a>
</center> </center>

2
resources/eloglang.brazilian
View File

@ -472,3 +472,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.bulgarian
View File

@ -472,3 +472,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.czech
View File

@ -469,3 +469,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

6
resources/eloglang.danish
View File

@ -468,3 +468,9 @@ Attribute "%s" is not allowed in config file = Attributten ''%s'' er ikke tillad
Only user <b>%s</b> can delete this entry = Kun bruger <b>%s</b> kan slette dette indlæg Only user <b>%s</b> can delete this entry = Kun bruger <b>%s</b> kan slette dette indlæg
File system full, ELOG cannot continue to work = Filsystemet er løbet fuld, ELOG kan ikke fortsætte File system full, ELOG cannot continue to work = Filsystemet er løbet fuld, ELOG kan ikke fortsætte
#
#---- please translate following items and then remove this comment ----#
#
3 Days =
Last 3 Days =

2
resources/eloglang.dutch
View File

@ -471,3 +471,5 @@ Only user <b>%s</b> can delete this entry = Alleen gebruiker <b>%s</b> kan dit b
#---- please translate following items and then remove this comment ----# #---- please translate following items and then remove this comment ----#
# #
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

6
resources/eloglang.french
View File

@ -465,3 +465,9 @@ Invalid URL = URL invalide
Attribute "%s" is not allowed in config file = L'attribut "%s" n'est pas autorisé dans le fichier de configuration Attribute "%s" is not allowed in config file = L'attribut "%s" n'est pas autorisé dans le fichier de configuration
Only user <b>%s</b> can delete this entry = Seul l'utilisateur <b>%s</b> peut supprimer cette entrée Only user <b>%s</b> can delete this entry = Seul l'utilisateur <b>%s</b> peut supprimer cette entrée
File system full, ELOG cannot continue to work = Le système de fichiers est plein, ELOG ne peut plus fonctionner File system full, ELOG cannot continue to work = Le système de fichiers est plein, ELOG ne peut plus fonctionner
#
#---- please translate following items and then remove this comment ----#
#
3 Days =
Last 3 Days =

3
resources/eloglang.german
View File

@ -464,4 +464,5 @@ Invalid URL = Ung
Attribute "%s" is not allowed in config file = Das Attribut "%s" ist in der Konfigurationsdatei nicht erlaubt Attribute "%s" is not allowed in config file = Das Attribut "%s" ist in der Konfigurationsdatei nicht erlaubt
Only user <b>%s</b> can delete this entry = Nur der Benutzer <b>%s</b> kann diesen Entrag löschen Only user <b>%s</b> can delete this entry = Nur der Benutzer <b>%s</b> kann diesen Entrag löschen
File system full, ELOG cannot continue to work = Dateisystem voll, ELOG kann nicht weiterarbeiten File system full, ELOG cannot continue to work = Dateisystem voll, ELOG kann nicht weiterarbeiten
3 Days = 3 Tage
Last 3 Days = Letzte 3 Tage

2
resources/eloglang.italian
View File

@ -467,3 +467,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.japanese
View File

@ -468,3 +468,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.ru_CP1251
View File

@ -473,3 +473,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.spanish
View File

@ -474,3 +474,5 @@ Only user <b>%s</b> can delete this entry = S
#---- please translate following items and then remove this comment ----# #---- please translate following items and then remove this comment ----#
# #
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

6
resources/eloglang.swedish
View File

@ -467,3 +467,9 @@ Invalid URL = Ogiltig URL
Attribute "%s" is not allowed in config file = Attributet "%s" är inte tillåtet i konfigurationsfilen Attribute "%s" is not allowed in config file = Attributet "%s" är inte tillåtet i konfigurationsfilen
Only user <b>%s</b> can delete this entry = Endast användare <b>%s</b> kan radera denna post Only user <b>%s</b> can delete this entry = Endast användare <b>%s</b> kan radera denna post
File system full, ELOG cannot continue to work = Filsystemet fullt, ELOG kan inte fortsätta arbeta File system full, ELOG cannot continue to work = Filsystemet fullt, ELOG kan inte fortsätta arbeta
#
#---- please translate following items and then remove this comment ----#
#
3 Days =
Last 3 Days =

2
resources/eloglang.turkish
View File

@ -471,3 +471,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.zh_CN-GB2312
View File

@ -470,3 +470,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

2
resources/eloglang.zh_CN-UTF8
View File

@ -470,3 +470,5 @@ Invalid URL =
Attribute "%s" is not allowed in config file = Attribute "%s" is not allowed in config file =
Only user <b>%s</b> can delete this entry = Only user <b>%s</b> can delete this entry =
File system full, ELOG cannot continue to work = File system full, ELOG cannot continue to work =
3 Days =
Last 3 Days =

667
src/crypt.c
View File

@ -30,13 +30,12 @@ typedef unsigned int uint32_t;
#endif #endif
/* Structure to save state of computation between the single steps. */ /* Structure to save state of computation between the single steps. */
struct sha256_ctx struct sha256_ctx {
{ uint32_t H[8];
uint32_t H[8];
uint32_t total[2]; uint32_t total[2];
uint32_t buflen; uint32_t buflen;
char buffer[128]; /* NB: always correctly aligned for uint32_t. */ char buffer[128]; /* NB: always correctly aligned for uint32_t. */
}; };
@ -50,58 +49,55 @@ struct sha256_ctx
/* This array contains the bytes used to pad the buffer to the next /* This array contains the bytes used to pad the buffer to the next
64-byte boundary. (FIPS 180-2:5.1.1) */ 64-byte boundary. (FIPS 180-2:5.1.1) */
static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/* Constants for SHA256 from FIPS 180-2:4.2.2. */ /* Constants for SHA256 from FIPS 180-2:4.2.2. */
static const uint32_t K[64] = static const uint32_t K[64] = {
{ 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
};
/* Process LEN bytes of BUFFER, accumulating context into CTX. /* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % 64 == 0. */ It is assumed that LEN % 64 == 0. */
static void static void sha256_process_block(const void *buffer, size_t len, struct sha256_ctx *ctx)
sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
{ {
const uint32_t *words = buffer; const uint32_t *words = buffer;
size_t nwords = len / sizeof (uint32_t); size_t nwords = len / sizeof(uint32_t);
uint32_t a = ctx->H[0]; uint32_t a = ctx->H[0];
uint32_t b = ctx->H[1]; uint32_t b = ctx->H[1];
uint32_t c = ctx->H[2]; uint32_t c = ctx->H[2];
uint32_t d = ctx->H[3]; uint32_t d = ctx->H[3];
uint32_t e = ctx->H[4]; uint32_t e = ctx->H[4];
uint32_t f = ctx->H[5]; uint32_t f = ctx->H[5];
uint32_t g = ctx->H[6]; uint32_t g = ctx->H[6];
uint32_t h = ctx->H[7]; uint32_t h = ctx->H[7];
/* First increment the byte count. FIPS 180-2 specifies the possible /* First increment the byte count. FIPS 180-2 specifies the possible
length of the file up to 2^64 bits. Here we only compute the length of the file up to 2^64 bits. Here we only compute the
number of bytes. Do a double word increment. */ number of bytes. Do a double word increment. */
ctx->total[0] += len; ctx->total[0] += len;
if (ctx->total[0] < (int)len) if (ctx->total[0] < (int) len)
++ctx->total[1]; ++ctx->total[1];
/* Process all bytes in the buffer with 64 bytes in each round of /* Process all bytes in the buffer with 64 bytes in each round of
the loop. */ the loop. */
while (nwords > 0) while (nwords > 0) {
{
uint32_t W[64]; uint32_t W[64];
unsigned int t; unsigned int t;
uint32_t a_save = a; uint32_t a_save = a;
@ -122,35 +118,33 @@ sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
#define R1(x) (CYCLIC (x, 17) ^ CYCLIC (x, 19) ^ (x >> 10)) #define R1(x) (CYCLIC (x, 17) ^ CYCLIC (x, 19) ^ (x >> 10))
/* It is unfortunate that C does not provide an operator for /* It is unfortunate that C does not provide an operator for
cyclic rotation. Hope the C compiler is smart enough. */ cyclic rotation. Hope the C compiler is smart enough. */
#define CYCLIC(w, s) ((w >> s) | (w << (32 - s))) #define CYCLIC(w, s) ((w >> s) | (w << (32 - s)))
/* Compute the message schedule according to FIPS 180-2:6.2.2 step 2. */ /* Compute the message schedule according to FIPS 180-2:6.2.2 step 2. */
for (t = 0; t < 16; ++t) for (t = 0; t < 16; ++t) {
{ W[t] = SWAP(*words);
W[t] = SWAP (*words); ++words;
++words; }
}
for (t = 16; t < 64; ++t) for (t = 16; t < 64; ++t)
W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16]; W[t] = R1(W[t - 2]) + W[t - 7] + R0(W[t - 15]) + W[t - 16];
/* The actual computation according to FIPS 180-2:6.2.2 step 3. */ /* The actual computation according to FIPS 180-2:6.2.2 step 3. */
for (t = 0; t < 64; ++t) for (t = 0; t < 64; ++t) {
{ uint32_t T1 = h + S1(e) + Ch(e, f, g) + K[t] + W[t];
uint32_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t]; uint32_t T2 = S0(a) + Maj(a, b, c);
uint32_t T2 = S0 (a) + Maj (a, b, c); h = g;
h = g; g = f;
g = f; f = e;
f = e; e = d + T1;
e = d + T1; d = c;
d = c; c = b;
c = b; b = a;
b = a; a = T1 + T2;
a = T1 + T2; }
}
/* Add the starting values of the context according to FIPS 180-2:6.2.2 /* Add the starting values of the context according to FIPS 180-2:6.2.2
step 4. */ step 4. */
a += a_save; a += a_save;
b += b_save; b += b_save;
c += c_save; c += c_save;
@ -162,36 +156,35 @@ sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
/* Prepare for the next round. */ /* Prepare for the next round. */
nwords -= 16; nwords -= 16;
} }
/* Put checksum in context given as argument. */ /* Put checksum in context given as argument. */
ctx->H[0] = a; ctx->H[0] = a;
ctx->H[1] = b; ctx->H[1] = b;
ctx->H[2] = c; ctx->H[2] = c;
ctx->H[3] = d; ctx->H[3] = d;
ctx->H[4] = e; ctx->H[4] = e;
ctx->H[5] = f; ctx->H[5] = f;
ctx->H[6] = g; ctx->H[6] = g;
ctx->H[7] = h; ctx->H[7] = h;
} }
/* Initialize structure containing state of computation. /* Initialize structure containing state of computation.
(FIPS 180-2:5.3.2) */ (FIPS 180-2:5.3.2) */
static void static void sha256_init_ctx(struct sha256_ctx *ctx)
sha256_init_ctx (struct sha256_ctx *ctx)
{ {
ctx->H[0] = 0x6a09e667; ctx->H[0] = 0x6a09e667;
ctx->H[1] = 0xbb67ae85; ctx->H[1] = 0xbb67ae85;
ctx->H[2] = 0x3c6ef372; ctx->H[2] = 0x3c6ef372;
ctx->H[3] = 0xa54ff53a; ctx->H[3] = 0xa54ff53a;
ctx->H[4] = 0x510e527f; ctx->H[4] = 0x510e527f;
ctx->H[5] = 0x9b05688c; ctx->H[5] = 0x9b05688c;
ctx->H[6] = 0x1f83d9ab; ctx->H[6] = 0x1f83d9ab;
ctx->H[7] = 0x5be0cd19; ctx->H[7] = 0x5be0cd19;
ctx->total[0] = ctx->total[1] = 0; ctx->total[0] = ctx->total[1] = 0;
ctx->buflen = 0; ctx->buflen = 0;
} }
@ -200,68 +193,61 @@ sha256_init_ctx (struct sha256_ctx *ctx)
IMPORTANT: On some systems it is required that RESBUF is correctly IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */ aligned for a 32 bits value. */
static void * static void *sha256_finish_ctx(struct sha256_ctx *ctx, void *resbuf)
sha256_finish_ctx (struct sha256_ctx *ctx, void *resbuf)
{ {
/* Take yet unprocessed bytes into account. */ /* Take yet unprocessed bytes into account. */
uint32_t bytes = ctx->buflen; uint32_t bytes = ctx->buflen;
size_t pad; size_t pad;
unsigned int i; unsigned int i;
/* Now count remaining bytes. */ /* Now count remaining bytes. */
ctx->total[0] += bytes; ctx->total[0] += bytes;
if (ctx->total[0] < bytes) if (ctx->total[0] < bytes)
++ctx->total[1]; ++ctx->total[1];
pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes; pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
memcpy (&ctx->buffer[bytes], fillbuf, pad); memcpy(&ctx->buffer[bytes], fillbuf, pad);
/* Put the 64-bit file length in *bits* at the end of the buffer. */ /* Put the 64-bit file length in *bits* at the end of the buffer. */
*(uint32_t *) &ctx->buffer[bytes + pad + 4] = SWAP (ctx->total[0] << 3); *(uint32_t *) & ctx->buffer[bytes + pad + 4] = SWAP(ctx->total[0] << 3);
*(uint32_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) | *(uint32_t *) & ctx->buffer[bytes + pad] = SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
(ctx->total[0] >> 29));
/* Process last bytes. */ /* Process last bytes. */
sha256_process_block (ctx->buffer, bytes + pad + 8, ctx); sha256_process_block(ctx->buffer, bytes + pad + 8, ctx);
/* Put result from CTX in first 32 bytes following RESBUF. */ /* Put result from CTX in first 32 bytes following RESBUF. */
for (i = 0; i < 8; ++i) for (i = 0; i < 8; ++i)
((uint32_t *) resbuf)[i] = SWAP (ctx->H[i]); ((uint32_t *) resbuf)[i] = SWAP(ctx->H[i]);
return resbuf; return resbuf;
} }
static void static void sha256_process_bytes(const void *buffer, size_t len, struct sha256_ctx *ctx)
sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
{ {
/* When we already have some bits in our internal buffer concatenate /* When we already have some bits in our internal buffer concatenate
both inputs first. */ both inputs first. */
if (ctx->buflen != 0) if (ctx->buflen != 0) {
{
size_t left_over = ctx->buflen; size_t left_over = ctx->buflen;
size_t add = 128 - left_over > len ? len : 128 - left_over; size_t add = 128 - left_over > len ? len : 128 - left_over;
memcpy (&ctx->buffer[left_over], buffer, add); memcpy(&ctx->buffer[left_over], buffer, add);
ctx->buflen += add; ctx->buflen += add;
if (ctx->buflen > 64) if (ctx->buflen > 64) {
{ sha256_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
sha256_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
ctx->buflen &= 63; ctx->buflen &= 63;
/* The regions in the following copy operation cannot overlap. */ /* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63], memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63], ctx->buflen);
ctx->buflen); }
}
buffer = (const char *) buffer + add; buffer = (const char *) buffer + add;
len -= add; len -= add;
} }
/* Process available complete blocks. */ /* Process available complete blocks. */
if (len >= 64) if (len >= 64) {
{
/* To check alignment gcc has an appropriate operator. Other /* To check alignment gcc has an appropriate operator. Other
compilers don't. */ compilers don't. */
#if __GNUC__ >= 2 #if __GNUC__ >= 2
@ -269,36 +255,31 @@ sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
#else #else
# define UNALIGNED_P(p) (((uintptr_t) p) % sizeof (uint32_t) != 0) # define UNALIGNED_P(p) (((uintptr_t) p) % sizeof (uint32_t) != 0)
#endif #endif
if (UNALIGNED_P (buffer)) if (UNALIGNED_P(buffer))
while (len > 64) while (len > 64) {
{ sha256_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
sha256_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx); buffer = (const char *) buffer + 64;
buffer = (const char *) buffer + 64; len -= 64;
len -= 64; } else {
} sha256_process_block(buffer, len & ~63, ctx);
else buffer = (const char *) buffer + (len & ~63);
{ len &= 63;
sha256_process_block (buffer, len & ~63, ctx); }
buffer = (const char *) buffer + (len & ~63); }
len &= 63;
}
}
/* Move remaining bytes into internal buffer. */ /* Move remaining bytes into internal buffer. */
if (len > 0) if (len > 0) {
{
size_t left_over = ctx->buflen; size_t left_over = ctx->buflen;
memcpy (&ctx->buffer[left_over], buffer, len); memcpy(&ctx->buffer[left_over], buffer, len);
left_over += len; left_over += len;
if (left_over >= 64) if (left_over >= 64) {
{ sha256_process_block(ctx->buffer, 64, ctx);
sha256_process_block (ctx->buffer, 64, ctx); left_over -= 64;
left_over -= 64; memcpy(ctx->buffer, &ctx->buffer[64], left_over);
memcpy (ctx->buffer, &ctx->buffer[64], left_over); }
}
ctx->buflen = left_over; ctx->buflen = left_over;
} }
} }
@ -319,214 +300,200 @@ static const char sha256_rounds_prefix[] = "rounds=";
#define ROUNDS_MAX 999999999 #define ROUNDS_MAX 999999999
/* Table with characters for base64 transformation. */ /* Table with characters for base64 transformation. */
static const char b64t[64] = static const char b64t[64] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static char * static char *sha256_crypt_r(const char *key, const char *salt, char *buffer, int buflen)
sha256_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
{ {
#ifdef _MSC_VER #ifdef _MSC_VER
unsigned char alt_result[32]; unsigned char alt_result[32];
unsigned char temp_result[32]; unsigned char temp_result[32];
#else #else
unsigned char alt_result[32] unsigned char alt_result[32]
__attribute__ ((__aligned__ (__alignof__ (uint32_t)))); __attribute__ ((__aligned__(__alignof__(uint32_t))));
unsigned char temp_result[32] unsigned char temp_result[32]
__attribute__ ((__aligned__ (__alignof__ (uint32_t)))); __attribute__ ((__aligned__(__alignof__(uint32_t))));
#endif #endif
struct sha256_ctx ctx; struct sha256_ctx ctx;
struct sha256_ctx alt_ctx; struct sha256_ctx alt_ctx;
size_t salt_len; size_t salt_len;
size_t key_len; size_t key_len;
size_t cnt; size_t cnt;
char *cp; char *cp;
char *copied_key = NULL; char *copied_key = NULL;
char *copied_salt = NULL; char *copied_salt = NULL;
char *p_bytes; char *p_bytes;
char *s_bytes; char *s_bytes;
/* Default number of rounds. */ /* Default number of rounds. */
size_t rounds = ROUNDS_DEFAULT; size_t rounds = ROUNDS_DEFAULT;
int rounds_custom = 0; int rounds_custom = 0;
/* Find beginning of salt string. The prefix should normally always /* Find beginning of salt string. The prefix should normally always
be present. Just in case it is not. */ be present. Just in case it is not. */
if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0) if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0)
/* Skip salt prefix. */ /* Skip salt prefix. */
salt += sizeof (sha256_salt_prefix) - 1; salt += sizeof(sha256_salt_prefix) - 1;
if (strncmp (salt, sha256_rounds_prefix, sizeof (sha256_rounds_prefix) - 1) if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1)
== 0) == 0) {
{ const char *num = salt + sizeof(sha256_rounds_prefix) - 1;
const char *num = salt + sizeof (sha256_rounds_prefix) - 1;
char *endp; char *endp;
unsigned long int srounds = strtoul (num, &endp, 10); unsigned long int srounds = strtoul(num, &endp, 10);
if (*endp == '$') if (*endp == '$') {
{ salt = endp + 1;
salt = endp + 1; rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
rounds = MAX (ROUNDS_MIN, MIN (srounds, ROUNDS_MAX)); rounds_custom = 1;
rounds_custom = 1; }
} }
}
salt_len = MIN (strcspn (salt, "$"), SALT_LEN_MAX); salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
key_len = strlen (key); key_len = strlen(key);
if ((key - (char *) 0) % __alignof__ (uint32_t) != 0) if ((key - (char *) 0) % __alignof__(uint32_t) != 0) {
{ char *tmp = (char *) alloca(key_len + __alignof__(uint32_t));
char *tmp = (char *) alloca (key_len + __alignof__ (uint32_t)); key = copied_key = memcpy(tmp + __alignof__(uint32_t)
key = copied_key = - (tmp - (char *) 0) % __alignof__(uint32_t), key, key_len);
memcpy (tmp + __alignof__ (uint32_t) }
- (tmp - (char *) 0) % __alignof__ (uint32_t),
key, key_len);
}
if ((salt - (char *) 0) % __alignof__ (uint32_t) != 0) if ((salt - (char *) 0) % __alignof__(uint32_t) != 0) {
{ char *tmp = (char *) alloca(salt_len + __alignof__(uint32_t));
char *tmp = (char *) alloca (salt_len + __alignof__ (uint32_t)); salt = copied_salt = memcpy(tmp + __alignof__(uint32_t)
salt = copied_salt = - (tmp - (char *) 0) % __alignof__(uint32_t), salt, salt_len);
memcpy (tmp + __alignof__ (uint32_t) }
- (tmp - (char *) 0) % __alignof__ (uint32_t),
salt, salt_len);
}
/* Prepare for the real work. */ /* Prepare for the real work. */
sha256_init_ctx (&ctx); sha256_init_ctx(&ctx);
/* Add the key string. */ /* Add the key string. */
sha256_process_bytes (key, key_len, &ctx); sha256_process_bytes(key, key_len, &ctx);
/* The last part is the salt string. This must be at most 16 /* The last part is the salt string. This must be at most 16
characters and it ends at the first `$' character (for characters and it ends at the first `$' character (for
compatibility with existing implementations). */ compatibility with existing implementations). */
sha256_process_bytes (salt, salt_len, &ctx); sha256_process_bytes(salt, salt_len, &ctx);
/* Compute alternate SHA256 sum with input KEY, SALT, and KEY. The /* Compute alternate SHA256 sum with input KEY, SALT, and KEY. The
final result will be added to the first context. */ final result will be added to the first context. */
sha256_init_ctx (&alt_ctx); sha256_init_ctx(&alt_ctx);
/* Add key. */ /* Add key. */
sha256_process_bytes (key, key_len, &alt_ctx); sha256_process_bytes(key, key_len, &alt_ctx);
/* Add salt. */ /* Add salt. */
sha256_process_bytes (salt, salt_len, &alt_ctx); sha256_process_bytes(salt, salt_len, &alt_ctx);
/* Add key again. */ /* Add key again. */
sha256_process_bytes (key, key_len, &alt_ctx); sha256_process_bytes(key, key_len, &alt_ctx);
/* Now get result of this (32 bytes) and add it to the other /* Now get result of this (32 bytes) and add it to the other
context. */ context. */
sha256_finish_ctx (&alt_ctx, alt_result); sha256_finish_ctx(&alt_ctx, alt_result);
/* Add for any character in the key one byte of the alternate sum. */ /* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 32; cnt -= 32) for (cnt = key_len; cnt > 32; cnt -= 32)
sha256_process_bytes (alt_result, 32, &ctx); sha256_process_bytes(alt_result, 32, &ctx);
sha256_process_bytes (alt_result, cnt, &ctx); sha256_process_bytes(alt_result, cnt, &ctx);
/* Take the binary representation of the length of the key and for every /* Take the binary representation of the length of the key and for every
1 add the alternate sum, for every 0 the key. */ 1 add the alternate sum, for every 0 the key. */
for (cnt = key_len; cnt > 0; cnt >>= 1) for (cnt = key_len; cnt > 0; cnt >>= 1)
if ((cnt & 1) != 0) if ((cnt & 1) != 0)
sha256_process_bytes (alt_result, 32, &ctx); sha256_process_bytes(alt_result, 32, &ctx);
else else
sha256_process_bytes (key, key_len, &ctx); sha256_process_bytes(key, key_len, &ctx);
/* Create intermediate result. */ /* Create intermediate result. */
sha256_finish_ctx (&ctx, alt_result); sha256_finish_ctx(&ctx, alt_result);
/* Start computation of P byte sequence. */ /* Start computation of P byte sequence. */
sha256_init_ctx (&alt_ctx); sha256_init_ctx(&alt_ctx);
/* For every character in the password add the entire password. */ /* For every character in the password add the entire password. */
for (cnt = 0; cnt < key_len; ++cnt) for (cnt = 0; cnt < key_len; ++cnt)
sha256_process_bytes (key, key_len, &alt_ctx); sha256_process_bytes(key, key_len, &alt_ctx);
/* Finish the digest. */ /* Finish the digest. */
sha256_finish_ctx (&alt_ctx, temp_result); sha256_finish_ctx(&alt_ctx, temp_result);
/* Create byte sequence P. */ /* Create byte sequence P. */
cp = p_bytes = alloca (key_len); cp = p_bytes = alloca(key_len);
for (cnt = key_len; cnt >= 32; cnt -= 32) for (cnt = key_len; cnt >= 32; cnt -= 32)
cp = mempcpy (cp, temp_result, 32); cp = mempcpy(cp, temp_result, 32);
memcpy (cp, temp_result, cnt); memcpy(cp, temp_result, cnt);
/* Start computation of S byte sequence. */ /* Start computation of S byte sequence. */
sha256_init_ctx (&alt_ctx); sha256_init_ctx(&alt_ctx);
/* For every character in the password add the entire password. */ /* For every character in the password add the entire password. */
for (cnt = 0; (int)cnt < 16 + alt_result[0]; ++cnt) for (cnt = 0; (int) cnt < 16 + alt_result[0]; ++cnt)
sha256_process_bytes (salt, salt_len, &alt_ctx); sha256_process_bytes(salt, salt_len, &alt_ctx);
/* Finish the digest. */ /* Finish the digest. */
sha256_finish_ctx (&alt_ctx, temp_result); sha256_finish_ctx(&alt_ctx, temp_result);
/* Create byte sequence S. */ /* Create byte sequence S. */
cp = s_bytes = alloca (salt_len); cp = s_bytes = alloca(salt_len);
for (cnt = salt_len; cnt >= 32; cnt -= 32) for (cnt = salt_len; cnt >= 32; cnt -= 32)
cp = mempcpy (cp, temp_result, 32); cp = mempcpy(cp, temp_result, 32);
memcpy (cp, temp_result, cnt); memcpy(cp, temp_result, cnt);
/* Repeatedly run the collected hash value through SHA256 to burn /* Repeatedly run the collected hash value through SHA256 to burn
CPU cycles. */ CPU cycles. */
for (cnt = 0; cnt < rounds; ++cnt) for (cnt = 0; cnt < rounds; ++cnt) {
{
/* New context. */ /* New context. */
sha256_init_ctx (&ctx); sha256_init_ctx(&ctx);
/* Add key or last result. */ /* Add key or last result. */
if ((cnt & 1) != 0) if ((cnt & 1) != 0)
sha256_process_bytes (p_bytes, key_len, &ctx); sha256_process_bytes(p_bytes, key_len, &ctx);
else else
sha256_process_bytes (alt_result, 32, &ctx); sha256_process_bytes(alt_result, 32, &ctx);
/* Add salt for numbers not divisible by 3. */ /* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0) if (cnt % 3 != 0)
sha256_process_bytes (s_bytes, salt_len, &ctx); sha256_process_bytes(s_bytes, salt_len, &ctx);
/* Add key for numbers not divisible by 7. */ /* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0) if (cnt % 7 != 0)
sha256_process_bytes (p_bytes, key_len, &ctx); sha256_process_bytes(p_bytes, key_len, &ctx);
/* Add key or last result. */ /* Add key or last result. */
if ((cnt & 1) != 0) if ((cnt & 1) != 0)
sha256_process_bytes (alt_result, 32, &ctx); sha256_process_bytes(alt_result, 32, &ctx);
else else
sha256_process_bytes (p_bytes, key_len, &ctx); sha256_process_bytes(p_bytes, key_len, &ctx);
/* Create intermediate result. */ /* Create intermediate result. */
sha256_finish_ctx (&ctx, alt_result); sha256_finish_ctx(&ctx, alt_result);
} }
/* Now we can construct the result string. It consists of three /* Now we can construct the result string. It consists of three
parts. */ parts. */
strncpy (buffer, sha256_salt_prefix, MAX (0, buflen)); strncpy(buffer, sha256_salt_prefix, MAX(0, buflen));
cp = buffer + strlen(buffer); cp = buffer + strlen(buffer);
buflen -= sizeof (sha256_salt_prefix) - 1; buflen -= sizeof(sha256_salt_prefix) - 1;
if (rounds_custom) if (rounds_custom) {
{
#ifdef _MSC_VER #ifdef _MSC_VER
int n = _snprintf (cp, MAX (0, buflen), "%s%zu$", int n = _snprintf(cp, MAX(0, buflen), "%s%zu$",
sha256_rounds_prefix, rounds); sha256_rounds_prefix, rounds);
#else #else
int n = snprintf (cp, MAX (0, buflen), "%s%zu$", int n = snprintf(cp, MAX(0, buflen), "%s%zu$",
sha256_rounds_prefix, rounds); sha256_rounds_prefix, rounds);
#endif #endif
cp += n; cp += n;
buflen -= n; buflen -= n;
} }
strncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len)); strncpy(cp, salt, MIN((size_t) MAX(0, buflen), salt_len));
cp = cp + strlen(cp); cp = cp + strlen(cp);
buflen -= MIN ((size_t) MAX (0, buflen), salt_len); buflen -= MIN((size_t) MAX(0, buflen), salt_len);
if (buflen > 0) if (buflen > 0) {
{
*cp++ = '$'; *cp++ = '$';
--buflen; --buflen;
} }
#define b64_from_24bit(B2, B1, B0, N) \ #define b64_from_24bit(B2, B1, B0, N) \
do { \ do { \
unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \ unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \
@ -539,70 +506,64 @@ sha256_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
} \ } \
} while (0) } while (0)
b64_from_24bit (alt_result[0], alt_result[10], alt_result[20], 4); b64_from_24bit(alt_result[0], alt_result[10], alt_result[20], 4);
b64_from_24bit (alt_result[21], alt_result[1], alt_result[11], 4); b64_from_24bit(alt_result[21], alt_result[1], alt_result[11], 4);
b64_from_24bit (alt_result[12], alt_result[22], alt_result[2], 4); b64_from_24bit(alt_result[12], alt_result[22], alt_result[2], 4);
b64_from_24bit (alt_result[3], alt_result[13], alt_result[23], 4); b64_from_24bit(alt_result[3], alt_result[13], alt_result[23], 4);
b64_from_24bit (alt_result[24], alt_result[4], alt_result[14], 4); b64_from_24bit(alt_result[24], alt_result[4], alt_result[14], 4);
b64_from_24bit (alt_result[15], alt_result[25], alt_result[5], 4); b64_from_24bit(alt_result[15], alt_result[25], alt_result[5], 4);
b64_from_24bit (alt_result[6], alt_result[16], alt_result[26], 4); b64_from_24bit(alt_result[6], alt_result[16], alt_result[26], 4);
b64_from_24bit (alt_result[27], alt_result[7], alt_result[17], 4); b64_from_24bit(alt_result[27], alt_result[7], alt_result[17], 4);
b64_from_24bit (alt_result[18], alt_result[28], alt_result[8], 4); b64_from_24bit(alt_result[18], alt_result[28], alt_result[8], 4);
b64_from_24bit (alt_result[9], alt_result[19], alt_result[29], 4); b64_from_24bit(alt_result[9], alt_result[19], alt_result[29], 4);
b64_from_24bit (0, alt_result[31], alt_result[30], 3); b64_from_24bit(0, alt_result[31], alt_result[30], 3);
if (buflen <= 0) if (buflen <= 0) {
{
errno = ERANGE; errno = ERANGE;
buffer = NULL; buffer = NULL;
} } else
else *cp = '\0'; /* Terminate the string. */
*cp = '\0'; /* Terminate the string. */
/* Clear the buffer for the intermediate result so that people /* Clear the buffer for the intermediate result so that people
attaching to processes or reading core dumps cannot get any attaching to processes or reading core dumps cannot get any
information. We do it in this way to clear correct_words[] information. We do it in this way to clear correct_words[]
inside the SHA256 implementation as well. */ inside the SHA256 implementation as well. */
sha256_init_ctx (&ctx); sha256_init_ctx(&ctx);
sha256_finish_ctx (&ctx, alt_result); sha256_finish_ctx(&ctx, alt_result);
memset (temp_result, '\0', sizeof (temp_result)); memset(temp_result, '\0', sizeof(temp_result));
memset (p_bytes, '\0', key_len); memset(p_bytes, '\0', key_len);
memset (s_bytes, '\0', salt_len); memset(s_bytes, '\0', salt_len);
memset (&ctx, '\0', sizeof (ctx)); memset(&ctx, '\0', sizeof(ctx));
memset (&alt_ctx, '\0', sizeof (alt_ctx)); memset(&alt_ctx, '\0', sizeof(alt_ctx));
if (copied_key != NULL) if (copied_key != NULL)
memset (copied_key, '\0', key_len); memset(copied_key, '\0', key_len);
if (copied_salt != NULL) if (copied_salt != NULL)
memset (copied_salt, '\0', salt_len); memset(copied_salt, '\0', salt_len);
return buffer; return buffer;
} }
/* This entry point is equivalent to the `crypt' function in Unix /* This entry point is equivalent to the `crypt' function in Unix
libcs. */ libcs. */
char * char *sha256_crypt(const char *key, const char *salt)
sha256_crypt (const char *key, const char *salt)
{ {
/* We don't want to have an arbitrary limit in the size of the /* We don't want to have an arbitrary limit in the size of the
password. We can compute an upper bound for the size of the password. We can compute an upper bound for the size of the
result in advance and so we can prepare the buffer we pass to result in advance and so we can prepare the buffer we pass to
`sha256_crypt_r'. */ `sha256_crypt_r'. */
static char *buffer; static char *buffer;
static int buflen; static int buflen;
int needed = (sizeof (sha256_salt_prefix) - 1 int needed = (sizeof(sha256_salt_prefix) - 1
+ sizeof (sha256_rounds_prefix) + 9 + 1 + sizeof(sha256_rounds_prefix) + 9 + 1 + strlen(salt) + 1 + 43 + 1);
+ strlen (salt) + 1 + 43 + 1);
if (buflen < needed) if (buflen < needed) {
{ char *new_buffer = (char *) realloc(buffer, needed);
char *new_buffer = (char *) realloc (buffer, needed);
if (new_buffer == NULL) if (new_buffer == NULL)
return NULL; return NULL;
buffer = new_buffer; buffer = new_buffer;
buflen = needed; buflen = needed;
} }
return sha256_crypt_r (key, salt, buffer, buflen); return sha256_crypt_r(key, salt, buffer, buflen);
} }

11
src/elog.c
View File

@ -9,7 +9,7 @@
\********************************************************************/ \********************************************************************/
#define VERSION "2.7.8" #define VERSION "2.8.0"
char svn_revision[] = "$Id$"; char svn_revision[] = "$Id$";
/* ELOG identification */ /* ELOG identification */
@ -91,7 +91,7 @@ void base64_encode(unsigned char *s, unsigned char *d, int size)
d += 4; d += 4;
if (d - p >= size - 3) if (d - p >= size - 3)
return; return;
} }
*d = 0; *d = 0;
while (pad--) while (pad--)
@ -455,7 +455,7 @@ INT retrieve_elog(char *host, int port, char *subdir, int ssl, char *experiment,
sprintf(request + strlen(request), "Cookie: "); sprintf(request + strlen(request), "Cookie: ");
first = 0; first = 0;
do_crypt(upwd, encrypted_passwd, sizeof(encrypted_passwd) ); do_crypt(upwd, encrypted_passwd, sizeof(encrypted_passwd));
sprintf(request + strlen(request), "upwd=%s;", encrypted_passwd); sprintf(request + strlen(request), "upwd=%s;", encrypted_passwd);
} }
@ -819,7 +819,8 @@ INT submit_elog(char *host, int port, int ssl, char *subdir, char *experiment,
if (upwd[0]) { if (upwd[0]) {
do_crypt(upwd, encrypted_passwd, sizeof(encrypted_passwd)); do_crypt(upwd, encrypted_passwd, sizeof(encrypted_passwd));
sprintf(content + strlen(content), sprintf(content + strlen(content),
"%s\r\nContent-Disposition: form-data; name=\"upwd\"\r\n\r\n%s\r\n", boundary, encrypted_passwd); "%s\r\nContent-Disposition: form-data; name=\"upwd\"\r\n\r\n%s\r\n", boundary,
encrypted_passwd);
} }
if (experiment[0]) if (experiment[0])
@ -901,7 +902,7 @@ INT submit_elog(char *host, int port, int ssl, char *subdir, char *experiment,
sprintf(request + strlen(request), "Content-Length: %d\r\n", content_length); sprintf(request + strlen(request), "Content-Length: %d\r\n", content_length);
if (passwd[0]) { if (passwd[0]) {
do_crypt(passwd, encrypted_passwd, sizeof(encrypted_passwd) ); do_crypt(passwd, encrypted_passwd, sizeof(encrypted_passwd));
sprintf(request + strlen(request), "Cookie: wpwd=%s\r\n", encrypted_passwd); sprintf(request + strlen(request), "Cookie: wpwd=%s\r\n", encrypted_passwd);
} }

36
src/elogd.c
View File

@ -9,7 +9,7 @@
\********************************************************************/ \********************************************************************/
/* Version of ELOG */ /* Version of ELOG */
#define VERSION "2.7.8" #define VERSION "2.8.0"
char svn_revision[] = "$Id$"; char svn_revision[] = "$Id$";
/* ELOG identification */ /* ELOG identification */
@ -1597,11 +1597,11 @@ void base64_bufenc(unsigned char *s, int len, char *d)
*(--d) = '='; *(--d) = '=';
} }
char *sha256_crypt (const char *key, const char *salt); char *sha256_crypt(const char *key, const char *salt);
void do_crypt(char *s, char *d, int size) void do_crypt(char *s, char *d, int size)
{ {
strlcpy(d, sha256_crypt(s, "$5$")+4, size); strlcpy(d, sha256_crypt(s, "$5$") + 4, size);
} }
/*------------------------------------------------------------------* /*------------------------------------------------------------------*
@ -6030,7 +6030,7 @@ char
void rsputs_elcode(LOGBOOK * lbs, BOOL email_notify, const char *str) void rsputs_elcode(LOGBOOK * lbs, BOOL email_notify, const char *str)
{ {
int i, j, k, l, m, elcode_disabled, elcode_disabled1, escape_char, ordered_list, substituted, inside_table, int i, j, k, l, m, elcode_disabled, elcode_disabled1, escape_char, ordered_list, substituted, inside_table,
smileys_enabled; smileys_enabled;
char *p, *pd, link[1000], link_text[1000], tmp[1000], attrib[1000], hattrib[1000], value[1000], char *p, *pd, link[1000], link_text[1000], tmp[1000], attrib[1000], hattrib[1000], value[1000],
subst[1000], base_url[256], param[256], *lstr, domain[256]; subst[1000], base_url[256], param[256], *lstr, domain[256];
@ -9134,7 +9134,7 @@ void compare_attributes(LOGBOOK * lbs, int message_id, char attrib[MAX_N_ATTR][N
memcpy(attrib, attr, sizeof(attr)); memcpy(attrib, attr, sizeof(attr));
else { else {
for (i = 0; i < lbs->n_attr; i++) for (i = 0; i < lbs->n_attr; i++)
if (!strieq(attrib[i], attr+i*NAME_LENGTH)) if (!strieq(attrib[i], attr + i * NAME_LENGTH))
sprintf(attrib[i], "- %s -", loc("keep original values")); sprintf(attrib[i], "- %s -", loc("keep original values"));
} }
(*n)++; (*n)++;
@ -9146,9 +9146,9 @@ void compare_attributes(LOGBOOK * lbs, int message_id, char attrib[MAX_N_ATTR][N
// go through all replies in threaded mode // go through all replies in threaded mode
n_reply = strbreak(reply_to, (char (*)[NAME_LENGTH]) list, MAX_N_ATTR, ",", FALSE); n_reply = strbreak(reply_to, (char (*)[NAME_LENGTH]) list, MAX_N_ATTR, ",", FALSE);
for (i = 0; i < n_reply; i++) { for (i = 0; i < n_reply; i++) {
compare_attributes(lbs, atoi(list+i*NAME_LENGTH), attrib, n); compare_attributes(lbs, atoi(list + i * NAME_LENGTH), attrib, n);
xfree(list); xfree(list);
} }
} }
@ -16773,8 +16773,8 @@ void display_line(LOGBOOK * lbs, int message_id, int number, char *mode, int exp
int *n_display, char *locked_by, int highlight, regex_t * re_buf, int highlight_mid, int *n_display, char *locked_by, int highlight, regex_t * re_buf, int highlight_mid,
int absolute_link) int absolute_link)
{ {
char str[NAME_LENGTH], ref[256], *nowrap, rowstyle[80], tdstyle[80], format[256], file_name[MAX_PATH_LENGTH], *slist, char str[NAME_LENGTH], ref[256], *nowrap, rowstyle[80], tdstyle[80], format[256],
*svalue, comment[256], param[80]; file_name[MAX_PATH_LENGTH], *slist, *svalue, comment[256], param[80];
char display[NAME_LENGTH], attr_icon[80]; char display[NAME_LENGTH], attr_icon[80];
int i, j, n, i_line, index, colspan, n_attachments, line_len, thumb_status, max_line_len, n_lines, int i, j, n, i_line, index, colspan, n_attachments, line_len, thumb_status, max_line_len, n_lines,
max_n_lines; max_n_lines;
@ -18277,7 +18277,8 @@ void show_page_filters(LOGBOOK * lbs, int n_msg, int page_n, BOOL mode_commands,
rsprintf("<option %s value=\"_all_\">%s\n", i == 0 ? "selected" : "", str); rsprintf("<option %s value=\"_all_\">%s\n", i == 0 ? "selected" : "", str);
rsprintf("<option %s value=1>%s %s\n", i == 1 ? "selected" : "", loc("Next"), loc("Day")); rsprintf("<option %s value=1>%s %s\n", i == 1 ? "selected" : "", loc("Next"), loc("Day"));
rsprintf("<option %s value=3>%s %s\n", i == 3 ? "selected" : "", loc("Next"), loc("3 Days")); rsprintf("<option %s value=3>%s %s\n", i == 3 ? "selected" : "", loc("Next"),
loc("3 Days"));
rsprintf("<option %s value=7>%s %s\n", i == 7 ? "selected" : "", loc("Next"), loc("Week")); rsprintf("<option %s value=7>%s %s\n", i == 7 ? "selected" : "", loc("Next"), loc("Week"));
rsprintf("<option %s value=31>%s %s\n", i == 31 ? "selected" : "", loc("Next"), rsprintf("<option %s value=31>%s %s\n", i == 31 ? "selected" : "", loc("Next"),
loc("Month")); loc("Month"));
@ -19061,8 +19062,8 @@ void show_elog_list(LOGBOOK * lbs, int past_n, int last_n, int page_n, BOOL defa
sort_attr[MAX_N_ATTR + 4][NAME_LENGTH], mode_cookie[80], charset[25], sort_item[NAME_LENGTH]; sort_attr[MAX_N_ATTR + 4][NAME_LENGTH], mode_cookie[80], charset[25], sort_item[NAME_LENGTH];
char *p, *pt1, *pt2, *slist, *svalue, *gattr, line[1024], iattr[256]; char *p, *pt1, *pt2, *slist, *svalue, *gattr, line[1024], iattr[256];
BOOL show_attachments, threaded, csv, xml, raw, mode_commands, expand, filtering, date_filtering, BOOL show_attachments, threaded, csv, xml, raw, mode_commands, expand, filtering, date_filtering,
disp_filter, show_text, text_in_attr, searched, found, disp_attr_link[MAX_N_ATTR + 4], disp_filter, show_text, text_in_attr, searched, found, disp_attr_link[MAX_N_ATTR + 4],
sort_attributes, show_att_column; sort_attributes, show_att_column;
time_t ltime, ltime_start, ltime_end, now, ltime1, ltime2, entry_ltime; time_t ltime, ltime_start, ltime_end, now, ltime1, ltime2, entry_ltime;
struct tm tms, *ptms; struct tm tms, *ptms;
MSG_LIST *msg_list; MSG_LIST *msg_list;
@ -19777,7 +19778,7 @@ void show_elog_list(LOGBOOK * lbs, int past_n, int last_n, int page_n, BOOL defa
} else if (strieq(sort_attr[i], loc("Date"))) { } else if (strieq(sort_attr[i], loc("Date"))) {
strlcat(msg_list[index].string, " ", sizeof(msg_list[index].string)); strlcat(msg_list[index].string, " ", sizeof(msg_list[index].string));
entry_ltime = date_to_ltime(date); entry_ltime = date_to_ltime(date);
sprintf(str, "%08d", (int)entry_ltime); sprintf(str, "%08d", (int) entry_ltime);
strlcat(msg_list[index].string, str, sizeof(msg_list[index].string)); strlcat(msg_list[index].string, str, sizeof(msg_list[index].string));
} }
} }
@ -20793,9 +20794,8 @@ void show_elog_list(LOGBOOK * lbs, int past_n, int last_n, int page_n, BOOL defa
level = 1; level = 1;
} }
} }
} else } else if (in_reply_to[0])
if (in_reply_to[0]) level = 1;
level = 1;
display_line(msg_list[index].lbs, message_id, index, mode, expand, level, printable, n_line, display_line(msg_list[index].lbs, message_id, index, mode, expand, level, printable, n_line,
show_attachments, show_att_column, date, in_reply_to, reply_to, n_attr_disp, disp_attr, show_attachments, show_att_column, date, in_reply_to, reply_to, n_attr_disp, disp_attr,
@ -24462,8 +24462,8 @@ BOOL convert_password_encoding(LOGBOOK * lbs)
printf("Converting password file for logbook \"%s\" to new encoding ... ", lbs->name); printf("Converting password file for logbook \"%s\" to new encoding ... ", lbs->name);
for (i=0 ; i<mxml_get_number_of_children(node) ; i++) { for (i = 0; i < mxml_get_number_of_children(node); i++) {
sprintf(str, "/list/user[%d]/password", i+1); sprintf(str, "/list/user[%d]/password", i + 1);
pwd = mxml_find_node(lbs->pwd_xml_tree, str); pwd = mxml_find_node(lbs->pwd_xml_tree, str);
if (pwd) { if (pwd) {
strlcpy(str, mxml_get_value(pwd), sizeof(str)); strlcpy(str, mxml_get_value(pwd), sizeof(str));