bitmessage/Jabit
bitmessage/Jabit
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Minor improvements and fixes

Browse Source 
I copied the Base64 encoder from Android platform (and converted it to Kotlin) because the Java one exists only since 1.8
(I don't now if I want to curse Java for not supporting Base64 out of the box earlier, or Android for not supporting a recent Java API)
This commit is contained in:
Christian Basler 2017-07-29 14:56:03 +02:00
parent d9e52c85c3
commit 6e79b0c50f
10 changed files with 726 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build.gradle
View File

@ -1,5 +1,5 @@
buildscript {
ext.kotlin_version = '1.1.3'
ext.kotlin_version = '1.1.3-2'
repositories {
mavenCentral()
}

2
core/src/main/kotlin/ch/dissem/bitmessage/ports/AbstractMessageRepository.kt
View File

@ -49,6 +49,8 @@ abstract class AbstractMessageRepository : MessageRepository, InternalContext.Co
}
}
override fun getAllMessages() = find("1=1")
override fun getMessage(id: Any): Plaintext {
if (id is Long) {
return single(find("id=" + id)) ?: throw IllegalArgumentException("There is no message with id $id")

2
core/src/main/kotlin/ch/dissem/bitmessage/ports/MessageRepository.kt
View File

@ -30,6 +30,8 @@ interface MessageRepository {
fun countUnread(label: Label?): Int
fun getAllMessages(): List<Plaintext>
fun getMessage(id: Any): Plaintext
fun getMessage(iv: InventoryVector): Plaintext?

13
core/src/main/kotlin/ch/dissem/bitmessage/utils/Base58.kt
View File

@ -88,21 +88,22 @@ object Base58 {
val input58 = ByteArray(input.length)
// Transform the String to a base58 byte sequence
for (i in 0..input.length - 1) {
val c = input[i]
val c = input[i].toInt()
var digit58 = -1
if (c.toInt() < 128) {
digit58 = INDEXES[c.toInt()]
val digit58 = if (c < 128) {
INDEXES[c]
} else {
-1
}
if (digit58 < 0) {
throw AddressFormatException("Illegal character $c at $i")
throw AddressFormatException("Illegal character ${input[i]} at $i")
}
input58[i] = digit58.toByte()
}
// Count leading zeroes
var zeroCount = 0
while (zeroCount < input58.size && input58[zeroCount].toInt() == 0) {
while (zeroCount < input58.size && input58[zeroCount] == 0.toByte()) {
++zeroCount
}
// The encoding

664
core/src/main/kotlin/ch/dissem/bitmessage/utils/Base64.kt Normal file
View File

@ -0,0 +1,664 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ch.dissem.bitmessage.utils
/**
* Utilities for encoding and decoding the Base64 representation of
* binary data. See RFCs <a
* href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
* href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
*/
object Base64 {
/**
* Encoder flag bit to omit the padding '=' characters at the end
* of the output (if any).
*/
const val NO_PADDING = 1
/**
* Encoder flag bit to omit all line terminators (i.e., the output
* will be on one long line).
*/
const val NO_WRAP = 2
/**
* Encoder flag bit to indicate lines should be terminated with a
* CRLF pair instead of just an LF. Has no effect if `NO_WRAP` is specified as well.
*/
const val CRLF = 4
/**
* Encoder/decoder flag bit to indicate using the "URL and
* filename safe" variant of Base64 (see RFC 3548 section 4) where
* `-` and `_` are used in place of `+` and
* `/`.
*/
const val URL_SAFE = 8
/**
* Default values for encoder/decoder flags.
*/
const val DEFAULT = NO_WRAP
// --------------------------------------------------------
// decoding
// --------------------------------------------------------
/**
* Decode the Base64-encoded data in input and return the data in
* a new byte array.
*
* The padding '=' characters at the end are considered optional, but
* if any are present, there must be the correct number of them.
* @param str the input String to decode, which is converted to
* * bytes using the default charset
* *
* @param flags controls certain features of the decoded output.
* * Pass `DEFAULT` to decode standard Base64.
* *
* *
* @throws IllegalArgumentException if the input contains
* * incorrect padding
*/
@JvmStatic
fun decode(str: String, flags: Int = DEFAULT): ByteArray {
val input = str.toByteArray(Charsets.US_ASCII)
return decode(input, 0, input.size, flags)
}
/**
* Decode the Base64-encoded data in input and return the data in
* a new byte array.
*
* The padding '=' characters at the end are considered optional, but
* if any are present, there must be the correct number of them.
* @param input the data to decode
* *
* @param offset the position within the input array at which to start
* *
* @param len the number of bytes of input to decode
* *
* @param flags controls certain features of the decoded output.
* * Pass `DEFAULT` to decode standard Base64.
* *
* *
* @throws IllegalArgumentException if the input contains
* * incorrect padding
*/
@JvmStatic
fun decode(input: ByteArray, offset: Int, len: Int, flags: Int = DEFAULT): ByteArray {
// Allocate space for the most data the input could represent.
// (It could contain less if it contains whitespace, etc.)
val decoder = Decoder(Options(flags), ByteArray(len * 3 / 4))
if (!decoder.process(input, offset, len, true)) {
throw IllegalArgumentException("bad base-64")
}
// Maybe we got lucky and allocated exactly enough output space.
if (decoder.op == decoder.output.size) {
return decoder.output
}
// Need to shorten the array, so allocate a new one of the
// right size and copy.
val temp = ByteArray(decoder.op)
System.arraycopy(decoder.output, 0, temp, 0, decoder.op)
return temp
}
// --------------------------------------------------------
// encoding
// --------------------------------------------------------
/**
* Base64-encode the given data and return a newly allocated
* String with the result.
* @param input the data to encode
* *
* @param flags controls certain features of the encoded output.
* * Passing `DEFAULT` results in output that
* * adheres to RFC 2045.
*/
fun encodeToString(input: ByteArray, flags: Int = DEFAULT): String {
return String(encode(input, 0, input.size, flags), Charsets.US_ASCII)
}
/**
* Base64-encode the given data and return a newly allocated
* byte[] with the result.
* @param input the data to encode
* *
* @param offset the position within the input array at which to
* * start
* *
* @param len the number of bytes of input to encode
* *
* @param flags controls certain features of the encoded output.
* * Passing `DEFAULT` results in output that
* * adheres to RFC 2045.
*/
fun encode(input: ByteArray, offset: Int, len: Int, flags: Int): ByteArray {
// Compute the exact length of the array we will produce.
var output_len = len / 3 * 4
val options = Options(flags)
// Account for the tail of the data and the padding bytes, if any.
if (options.do_padding) {
if (len % 3 > 0) {
output_len += 4
}
} else {
when (len % 3) {
0 -> {
}
1 -> output_len += 2
2 -> output_len += 3
}
}
// Account for the newlines, if any.
if (options.do_newline && len > 0) {
output_len += ((len - 1) / (3 * Encoder.LINE_GROUPS) + 1) * if (options.do_cr) 2 else 1
}
val encoder = Encoder(options, ByteArray(output_len))
encoder.process(input, offset, len, true)
assert(encoder.op == output_len)
return encoder.output
}
}
class Options(flags: Int) {
val do_padding = flags and Base64.NO_PADDING == 0
val do_newline = flags and Base64.NO_WRAP == 0
val do_cr = flags and Base64.CRLF != 0
val url_safe = flags and Base64.URL_SAFE == 0
}
private abstract class Coder(val output: ByteArray) {
var op = 0
/**
* Encode/decode another block of input data. this.output is
* provided by the caller, and must be big enough to hold all
* the coded data. On exit, this.opwill be set to the length
* of the coded data.
*
* @param finish true if this is the final call to process for
* this object. Will finalize the coder state and
* include any final bytes in the output.
*
* @return true if the input so far is good; false if some
* error has been detected in the input stream..
*/
abstract fun process(input: ByteArray, offset: Int, len: Int, finish: Boolean): Boolean
/**
* @return the maximum number of bytes a call to process()
* could produce for the given number of input bytes. This may
* be an overestimate.
*/
abstract fun maxOutputSize(len: Int): Int
}
private class Decoder(options: Options, output: ByteArray) : Coder(output) {
/**
* States 0-3 are reading through the next input tuple.
* State 4 is having read one '=' and expecting exactly
* one more.
* State 5 is expecting no more data or padding characters
* in the input.
* State 6 is the error state; an error has been detected
* in the input and no future input can "fix" it.
*/
private var state: Int = 0 // state number (0 to 6)
private var value: Int = 0
private val alphabet = if (options.url_safe) DECODE else DECODE_WEBSAFE
/**
* @return an overestimate for the number of bytes `len` bytes could decode to.
*/
override fun maxOutputSize(len: Int): Int {
return len * 3 / 4 + 10
}
/**
* Decode another block of input data.
* @return true if the state machine is still healthy. false if
* * bad base-64 data has been detected in the input stream.
*/
override fun process(input: ByteArray, offset: Int, len: Int, finish: Boolean): Boolean {
var end = len
if (this.state == 6) return false
var p = offset
end += offset
// Using local variables makes the decoder about 12%
// faster than if we manipulate the member variables in
// the loop. (Even alphabet makes a measurable
// difference, which is somewhat surprising to me since
// the member variable is final.)
var state = this.state
var value = this.value
var op = 0
val output = this.output
val alphabet = this.alphabet
while (p < end) {
// Try the fast path: we're starting a new tuple and the
// next four bytes of the input stream are all data
// bytes. This corresponds to going through states
// 0-1-2-3-0. We expect to use this method for most of
// the data.
//
// If any of the next four bytes of input are non-data
// (whitespace, etc.), value will end up negative. (All
// the non-data values in decode are small negative
// numbers, so shifting any of them up and or'ing them
// together will result in a value with its top bit set.)
//
// You can remove this whole block and the output should
// be the same, just slower.
if (state == 0) {
fun nextVal(): Int {
value = alphabet[input[p].toInt() and 0xff] shl 18 or
(alphabet[input[p + 1].toInt() and 0xff] shl 12) or
(alphabet[input[p + 2].toInt() and 0xff] shl 6) or
alphabet[input[p + 3].toInt() and 0xff]
return value
}
while (p + 4 <= end && nextVal() >= 0) {
output[op + 2] = value.toByte()
output[op + 1] = (value shr 8).toByte()
output[op] = (value shr 16).toByte()
op += 3
p += 4
}
if (p >= end) break
}
// The fast path isn't available -- either we've read a
// partial tuple, or the next four input bytes aren't all
// data, or whatever. Fall back to the slower state
// machine implementation.
val d = alphabet[input[p++].toInt() and 0xff]
when (state) {
0 -> if (d >= 0) {
value = d
++state
} else if (d != SKIP) {
this.state = 6
return false
}
1 -> if (d >= 0) {
value = value shl 6 or d
++state
} else if (d != SKIP) {
this.state = 6
return false
}
2 -> if (d >= 0) {
value = value shl 6 or d
++state
} else if (d == EQUALS) {
// Emit the last (partial) output tuple;
// expect exactly one more padding character.
output[op++] = (value shr 4).toByte()
state = 4
} else if (d != SKIP) {
this.state = 6
return false
}
3 -> if (d >= 0) {
// Emit the output triple and return to state 0.
value = value shl 6 or d
output[op + 2] = value.toByte()
output[op + 1] = (value shr 8).toByte()
output[op] = (value shr 16).toByte()
op += 3
state = 0
} else if (d == EQUALS) {
// Emit the last (partial) output tuple;
// expect no further data or padding characters.
output[op + 1] = (value shr 2).toByte()
output[op] = (value shr 10).toByte()
op += 2
state = 5
} else if (d != SKIP) {
this.state = 6
return false
}
4 -> if (d == EQUALS) {
++state
} else if (d != SKIP) {
this.state = 6
return false
}
5 -> if (d != SKIP) {
this.state = 6
return false
}
}
}
if (!finish) {
// We're out of input, but a future call could provide
// more.
this.state = state
this.value = value
this.op = op
return true
}
// Done reading input. Now figure out where we are left in
// the state machine and finish up.
when (state) {
0 -> {
}
1 -> {
// Read one extra input byte, which isn't enough to
// make another output byte. Illegal.
this.state = 6
return false
}
2 ->
// Read two extra input bytes, enough to emit 1 more
// output byte. Fine.
output[op++] = (value shr 4).toByte()
3 -> {
// Read three extra input bytes, enough to emit 2 more
// output bytes. Fine.
output[op++] = (value shr 10).toByte()
output[op++] = (value shr 2).toByte()
}
4 -> {
// Read one padding '=' when we expected 2. Illegal.
this.state = 6
return false
}
5 -> {
}
}// Output length is a multiple of three. Fine.
// Read all the padding '='s we expected and no more.
// Fine.
this.state = state
this.op = op
return true
}
companion object {
/**
* Lookup table for turning bytes into their position in the
* Base64 alphabet.
*/
private val DECODE = intArrayOf(
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
)
/**
* Decode lookup table for the "web safe" variant (RFC 3548
* sec. 4) where - and _ replace + and /.
*/
private val DECODE_WEBSAFE = intArrayOf(
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
)
/** Non-data values in the DECODE arrays. */
private val SKIP = -1
private val EQUALS = -2
}
}
private class Encoder(val options: Options, output: ByteArray) : Coder(output) {
private val alphabet: ByteArray = if (options.url_safe) ENCODE else ENCODE_WEBSAFE
private val tail = ByteArray(2)
private var tailLen = 0
private var count = if (options.do_newline) LINE_GROUPS else -1
/**
* @return an overestimate for the number of bytes `len` bytes could encode to.
*/
override fun maxOutputSize(len: Int): Int {
return len * 8 / 5 + 10
}
override fun process(input: ByteArray, offset: Int, len: Int, finish: Boolean): Boolean {
var end = len
// Using local variables makes the encoder about 9% faster.
val alphabet = this.alphabet
val output = this.output
var op = 0
var count = this.count
var p = offset
end += offset
var v = -1
// First we need to concatenate the tail of the previous call
// with any input bytes available now and see if we can empty
// the tail.
when (tailLen) {
0 -> {
}
1 -> {
if (p + 2 <= end) {
// A 1-byte tail with at least 2 bytes of
// input available now.
v = tail[0].toInt() and 0xff shl 16 or
(input[p++].toInt() and 0xff shl 8) or
(input[p++].toInt() and 0xff)
tailLen = 0
}
}
2 -> if (p + 1 <= end) {
// A 2-byte tail with at least 1 byte of input.
v = tail[0].toInt() and 0xff shl 16 or
(tail[1].toInt() and 0xff shl 8) or
(input[p++].toInt() and 0xff)
tailLen = 0
}
}// There was no tail.
if (v != -1) {
output[op++] = alphabet[v shr 18 and 0x3f]
output[op++] = alphabet[v shr 12 and 0x3f]
output[op++] = alphabet[v shr 6 and 0x3f]
output[op++] = alphabet[v and 0x3f]
if (--count == 0) {
if (options.do_cr) output[op++] = CR
output[op++] = NL
count = LINE_GROUPS
}
}
// At this point either there is no tail, or there are fewer
// than 3 bytes of input available.
// The main loop, turning 3 input bytes into 4 output bytes on
// each iteration.
while (p + 3 <= end) {
v = input[p].toInt() and 0xff shl 16 or
(input[p + 1].toInt() and 0xff shl 8) or
(input[p + 2].toInt() and 0xff)
output[op] = alphabet[v shr 18 and 0x3f]
output[op + 1] = alphabet[v shr 12 and 0x3f]
output[op + 2] = alphabet[v shr 6 and 0x3f]
output[op + 3] = alphabet[v and 0x3f]
p += 3
op += 4
if (--count == 0) {
if (options.do_cr) output[op++] = CR
output[op++] = NL
count = LINE_GROUPS
}
}
if (finish) {
// Finish up the tail of the input. Note that we need to
// consume any bytes in tail before any bytes
// remaining in input; there should be at most two bytes
// total.
if (p - tailLen == end - 1) {
var t = 0
v = (if (tailLen > 0) tail[t++] else input[p++]).toInt() and 0xff shl 4
tailLen -= t
output[op++] = alphabet[v shr 6 and 0x3f]
output[op++] = alphabet[v and 0x3f]
if (options.do_padding) {
output[op++] = PAD
output[op++] = PAD
}
if (options.do_newline) {
if (options.do_cr) output[op++] = CR
output[op++] = NL
}
} else if (p - tailLen == end - 2) {
var t = 0
v = (if (tailLen > 1) tail[t++] else input[p++]).toInt() and 0xff shl 10 or ((if (tailLen > 0) tail[t++] else input[p++]).toInt() and 0xff shl 2)
tailLen -= t
output[op++] = alphabet[v shr 12 and 0x3f]
output[op++] = alphabet[v shr 6 and 0x3f]
output[op++] = alphabet[v and 0x3f]
if (options.do_padding) {
output[op++] = PAD
}
if (options.do_newline) {
if (options.do_cr) output[op++] = CR
output[op++] = NL
}
} else if (options.do_newline && op > 0 && count != LINE_GROUPS) {
if (options.do_cr) output[op++] = CR
output[op++] = NL
}
assert(tailLen == 0)
assert(p == end)
} else {
// Save the leftovers in tail to be consumed on the next
// call to encodeInternal.
if (p == end - 1) {
tail[tailLen++] = input[p]
} else if (p == end - 2) {
tail[tailLen++] = input[p]
tail[tailLen++] = input[p + 1]
}
}
this.op = op
this.count = count
return true
}
companion object {
private const val PAD = '='.toByte()
private const val CR = '\r'.toByte()
private const val NL = '\n'.toByte()
/**
* Emit a new line every this many output tuples. Corresponds to
* a 76-character line length (the maximum allowable according to
* [RFC 2045](http://www.ietf.org/rfc/rfc2045.txt)).
*/
val LINE_GROUPS = 19
/**
* Lookup table for turning Base64 alphabet positions (6 bits)
* into output bytes.
*/
private val ENCODE = charArrayOf(
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
).map { it.toByte() }.toByteArray()
/**
* Lookup table for turning Base64 alphabet positions (6 bits)
* into output bytes.
*/
private val ENCODE_WEBSAFE = charArrayOf(
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
).map { it.toByte() }.toByteArray()
}
}

6
core/src/main/kotlin/ch/dissem/bitmessage/utils/UnixTime.kt
View File

@ -23,15 +23,15 @@ object UnixTime {
/**
* Length of a minute in seconds, intended for use with [.now].
*/
@JvmField val MINUTE = 60L
const val MINUTE = 60L
/**
* Length of an hour in seconds, intended for use with [.now].
*/
@JvmField val HOUR = 60L * MINUTE
const val HOUR = 60L * MINUTE
/**
* Length of a day in seconds, intended for use with [.now].
*/
@JvmField val DAY = 24L * HOUR
const val DAY = 24L * HOUR
/**
* @return the time in second based Unix time ([System.currentTimeMillis]/1000)

2
core/src/main/resources/nodes.txt
View File

@ -1,6 +1,6 @@
[stream 1]
dissem.ch:8444
bitmessage.dissem.ch:8444
bootstrap8080.bitmessage.org:8080
bootstrap8444.bitmessage.org:8444

35
core/src/test/kotlin/ch/dissem/bitmessage/utils/Base64Test.kt Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright 2017 Christian Basler
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ch.dissem.bitmessage.utils
import ch.dissem.bitmessage.cryptography.bc.BouncyCryptography
import org.hamcrest.Matchers.`is`
import org.junit.Assert.assertThat
import org.junit.Test
class Base64Test {
@Test
fun `ensure data is encoded and decoded correctly`() {
val cryptography = BouncyCryptography()
for (i in 100..200) {
val data = cryptography.randomBytes(i)
val string = Base64.encodeToString(data)
val decoded = Base64.decode(string)
assertThat(decoded, `is`(data))
}
}
}

10
exports/src/main/kotlin/ch/dissem/bitmessage/exports/ContactExport.kt
View File

@ -19,18 +19,17 @@ package ch.dissem.bitmessage.exports
import ch.dissem.bitmessage.entity.BitmessageAddress
import ch.dissem.bitmessage.entity.valueobject.PrivateKey
import ch.dissem.bitmessage.factory.Factory
import ch.dissem.bitmessage.utils.Base64
import ch.dissem.bitmessage.utils.Encode
import com.beust.klaxon.*
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.util.*
/**
* Exports and imports contacts and identities
*/
object ContactExport {
fun exportContacts(contacts: List<BitmessageAddress>, includePrivateKey: Boolean = false) = json {
val base64 = Base64.getEncoder()
array(
contacts.map {
obj(
@ -41,10 +40,10 @@ object ContactExport {
"pubkey" to it.pubkey?.let {
val out = ByteArrayOutputStream()
it.writeUnencrypted(out)
base64.encodeToString(out.toByteArray())
Base64.encodeToString(out.toByteArray())
},
"privateKey" to if (includePrivateKey) {
it.privateKey?.let { base64.encodeToString(Encode.bytes(it)) }
it.privateKey?.let { Base64.encodeToString(Encode.bytes(it)) }
} else {
null
}
@ -55,8 +54,7 @@ object ContactExport {
fun importContacts(input: JsonArray<*>): List<BitmessageAddress> {
return input.filterIsInstance(JsonObject::class.java).map { json ->
val base64 = Base64.getDecoder()
fun JsonObject.bytes(fieldName: String) = string(fieldName)?.let { base64.decode(it) }
fun JsonObject.bytes(fieldName: String) = string(fieldName)?.let { Base64.decode(it) }
val privateKey = json.bytes("privateKey")?.let { PrivateKey.read(ByteArrayInputStream(it)) }
if (privateKey != null) {
BitmessageAddress(privateKey)

15
exports/src/main/kotlin/ch/dissem/bitmessage/exports/MessageExport.kt
View File

@ -20,6 +20,7 @@ import ch.dissem.bitmessage.entity.BitmessageAddress
import ch.dissem.bitmessage.entity.Plaintext
import ch.dissem.bitmessage.entity.valueobject.InventoryVector
import ch.dissem.bitmessage.entity.valueobject.Label
import ch.dissem.bitmessage.utils.Base64
import ch.dissem.bitmessage.utils.Encode
import ch.dissem.bitmessage.utils.TTL
import com.beust.klaxon.*
@ -42,7 +43,6 @@ object MessageExport {
}
fun exportMessages(messages: List<Plaintext>) = json {
val base64 = Base64.getEncoder()
array(messages.map {
obj(
"type" to it.type.name,
@ -52,13 +52,13 @@ object MessageExport {
"body" to it.text,
"conversationId" to it.conversationId.toString(),
"msgId" to it.inventoryVector?.hash?.let { base64.encodeToString(it) },
"msgId" to it.inventoryVector?.hash?.let { Base64.encodeToString(it) },
"encoding" to it.encodingCode,
"status" to it.status.name,
"message" to base64.encodeToString(it.message),
"ackData" to it.ackData?.let { base64.encodeToString(it) },
"ackMessage" to it.ackMessage?.let { base64.encodeToString(Encode.bytes(it)) },
"signature" to it.signature?.let { base64.encodeToString(it) },
"message" to Base64.encodeToString(it.message),
"ackData" to it.ackData?.let { Base64.encodeToString(it) },
"ackMessage" to it.ackMessage?.let { Base64.encodeToString(Encode.bytes(it)) },
"signature" to it.signature?.let { Base64.encodeToString(it) },
"sent" to it.sent,
"received" to it.received,
"ttl" to it.ttl,
@ -69,8 +69,7 @@ object MessageExport {
fun importMessages(input: JsonArray<*>, labels: Map<String, Label>): List<Plaintext> {
return input.filterIsInstance(JsonObject::class.java).map { json ->
val base64 = Base64.getDecoder()
fun JsonObject.bytes(fieldName: String) = string(fieldName)?.let { base64.decode(it) }
fun JsonObject.bytes(fieldName: String) = string(fieldName)?.let { Base64.decode(it) }
Plaintext.Builder(Plaintext.Type.valueOf(json.string("type") ?: "MSG"))
.from(json.string("from")?.let { BitmessageAddress(it) } ?: throw IllegalArgumentException("'from' address expected"))
.to(json.string("to")?.let { BitmessageAddress(it) })