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

🔥 Remove duplicate code

Browse Source
This commit is contained in:
Christian Basler
2018-05-31 22:33:26 +02:00
parent fafabf64a3
commit 37cda3df56
3 changed files with 89 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
core/src/main/kotlin/ch/dissem/bitmessage/factory/V3MessageFactory.kt
View File

@@ -62,13 +62,13 @@ object V3MessageFactory {
fun getPayload(command: String, stream: InputStream, length: Int): MessagePayload? = when (command) {
"version" -> parseVersion(stream)
"verack" -> VerAck()
"addr" -> parseAddr(stream)
"inv" -> parseInv(stream)
"getdata" -> parseGetData(stream)
"addr" -> Addr(parseList(stream) { parseAddress(it, false) })
"inv" -> Inv(parseList(stream) { parseInventoryVector(it) })
"getdata" -> GetData(parseList(stream) { parseInventoryVector(it) })
"object" -> readObject(stream, length)
"custom" -> readCustom(stream, length)
else -> {
LOG.debug("Unknown command: " + command)
LOG.debug("Unknown command: $command")
null
}
}
@@ -85,73 +85,40 @@ object V3MessageFactory {
val stream = Decode.varInt(input, counter)
val data = Decode.bytes(input, length - counter.length())
var payload: ObjectPayload
try {
val dataStream = ByteArrayInputStream(data)
payload = Factory.getObjectPayload(objectType, version, stream, dataStream, data.size)
val payload: ObjectPayload = try {
Factory.getObjectPayload(objectType, version, stream, ByteArrayInputStream(data), data.size)
} catch (e: Exception) {
if (LOG.isTraceEnabled) {
LOG.trace("Could not parse object payload - using generic payload instead", e)
LOG.trace(Strings.hex(data))
}
payload = GenericPayload(version, stream, data)
GenericPayload(version, stream, data)
}
return ObjectMessage.Builder()
.nonce(nonce)
.expiresTime(expiresTime)
.objectType(objectType)
.stream(stream)
.payload(payload)
.build()
return ObjectMessage(
nonce, expiresTime, payload, objectType, version, stream
)
}
private fun parseGetData(stream: InputStream): GetData {
private fun <T> parseList(stream: InputStream, reader: (InputStream) -> (T)): List<T> {
val count = Decode.varInt(stream)
val inventoryVectors = LinkedList<InventoryVector>()
val items = LinkedList<T>()
for (i in 0 until count) {
inventoryVectors.add(parseInventoryVector(stream))
items.add(reader(stream))
}
return GetData(inventoryVectors)
return items
}
private fun parseInv(stream: InputStream): Inv {
val count = Decode.varInt(stream)
val inventoryVectors = LinkedList<InventoryVector>()
for (i in 0 until count) {
inventoryVectors.add(parseInventoryVector(stream))
}
return Inv(inventoryVectors)
}
private fun parseAddr(stream: InputStream): Addr {
val count = Decode.varInt(stream)
val networkAddresses = LinkedList<NetworkAddress>()
for (i in 0 until count) {
networkAddresses.add(parseAddress(stream, false))
}
return Addr(networkAddresses)
}
private fun parseVersion(stream: InputStream): Version {
val version = Decode.int32(stream)
val services = Decode.int64(stream)
val timestamp = Decode.int64(stream)
val addrRecv = parseAddress(stream, true)
val addrFrom = parseAddress(stream, true)
val nonce = Decode.int64(stream)
val userAgent = Decode.varString(stream)
val streamNumbers = Decode.varIntList(stream)
return Version.Builder()
.version(version)
.services(services)
.timestamp(timestamp)
.addrRecv(addrRecv).addrFrom(addrFrom)
.nonce(nonce)
.userAgent(userAgent)
.streams(*streamNumbers).build()
}
private fun parseVersion(stream: InputStream) = Version(
version = Decode.int32(stream),
services = Decode.int64(stream),
timestamp = Decode.int64(stream),
addrRecv = parseAddress(stream, true),
addrFrom = parseAddress(stream, true),
nonce = Decode.int64(stream),
userAgent = Decode.varString(stream),
streams = Decode.varIntList(stream)
)
private fun parseInventoryVector(stream: InputStream) = InventoryVector(Decode.bytes(stream, 32))
@@ -168,13 +135,10 @@ object V3MessageFactory {
val services = Decode.int64(stream)
val ipv6 = Decode.bytes(stream, 16)
val port = Decode.uint16(stream)
return NetworkAddress.Builder()
.time(time)
.stream(streamNumber)
.services(services)
.ipv6(ipv6)
.port(port)
.build()
return NetworkAddress(
time, streamNumber, services, ipv6, port
)
}
private fun testChecksum(checksum: ByteArray, payload: ByteArray): Boolean {

61
core/src/main/kotlin/ch/dissem/bitmessage/ports/AbstractCryptography.kt
View File

@@ -36,12 +36,16 @@ import javax.crypto.spec.SecretKeySpec
/**
* Implements everything that isn't directly dependent on either Spongy- or Bouncycastle.
*/
abstract class AbstractCryptography protected constructor(@JvmField protected val provider: Provider) : Cryptography, InternalContext.ContextHolder {
abstract class AbstractCryptography protected constructor(@JvmField protected val provider: Provider) : Cryptography,
InternalContext.ContextHolder {
private lateinit var ctx: InternalContext
@JvmField protected val ALGORITHM_ECDSA = "ECDSA"
@JvmField protected val ALGORITHM_ECDSA_SHA1 = "SHA1withECDSA"
@JvmField protected val ALGORITHM_EVP_SHA256 = "SHA256withECDSA"
@JvmField
protected val ALGORITHM_ECDSA = "ECDSA"
@JvmField
protected val ALGORITHM_ECDSA_SHA1 = "SHA1withECDSA"
@JvmField
protected val ALGORITHM_EVP_SHA256 = "SHA256withECDSA"
override fun setContext(context: InternalContext) {
ctx = context
@@ -65,8 +69,12 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
return mda.digest(mda.digest())
}
override fun doubleSha512(data: ByteArray, length: Int): ByteArray {
val mda = md("SHA-512")
override fun doubleSha512(data: ByteArray, length: Int) = doubleHash("SHA-512", data, length);
override fun doubleSha256(data: ByteArray, length: Int) = doubleHash("SHA-256", data, length);
private fun doubleHash(method: String, data: ByteArray, length: Int): ByteArray {
val mda = md(method)
mda.update(data, 0, length)
return mda.digest(mda.digest())
}
@@ -75,12 +83,6 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
return hash("RIPEMD160", *data)
}
override fun doubleSha256(data: ByteArray, length: Int): ByteArray {
val mda = md("SHA-256")
mda.update(data, 0, length)
return mda.digest(mda.digest())
}
override fun sha1(vararg data: ByteArray): ByteArray {
return hash("SHA-1", *data)
}
@@ -91,13 +93,17 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
return result
}
override fun doProofOfWork(objectMessage: ObjectMessage, nonceTrialsPerByte: Long,
extraBytes: Long, callback: ProofOfWorkEngine.Callback) {
override fun doProofOfWork(
objectMessage: ObjectMessage, nonceTrialsPerByte: Long,
extraBytes: Long, callback: ProofOfWorkEngine.Callback
) {
val initialHash = getInitialHash(objectMessage)
val target = getProofOfWorkTarget(objectMessage,
max(nonceTrialsPerByte, NETWORK_NONCE_TRIALS_PER_BYTE), max(extraBytes, NETWORK_EXTRA_BYTES))
val target = getProofOfWorkTarget(
objectMessage,
max(nonceTrialsPerByte, NETWORK_NONCE_TRIALS_PER_BYTE), max(extraBytes, NETWORK_EXTRA_BYTES)
)
ctx.proofOfWorkEngine.calculateNonce(initialHash, target, callback)
}
@@ -105,7 +111,10 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
@Throws(InsufficientProofOfWorkException::class)
override fun checkProofOfWork(objectMessage: ObjectMessage, nonceTrialsPerByte: Long, extraBytes: Long) {
val target = getProofOfWorkTarget(objectMessage, nonceTrialsPerByte, extraBytes)
val value = doubleSha512(objectMessage.nonce ?: throw ApplicationException("Object without nonce"), getInitialHash(objectMessage))
val value = doubleSha512(
objectMessage.nonce ?: throw ApplicationException("Object without nonce"),
getInitialHash(objectMessage)
)
if (Bytes.lt(target, value, 8)) {
throw InsufficientProofOfWorkException(target, value)
}
@@ -136,7 +145,11 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
return sha512(objectMessage.payloadBytesWithoutNonce)
}
override fun getProofOfWorkTarget(objectMessage: ObjectMessage, nonceTrialsPerByte: Long, extraBytes: Long): ByteArray {
override fun getProofOfWorkTarget(
objectMessage: ObjectMessage,
nonceTrialsPerByte: Long,
extraBytes: Long
): ByteArray {
@Suppress("NAME_SHADOWING")
val nonceTrialsPerByte = if (nonceTrialsPerByte == 0L) NETWORK_NONCE_TRIALS_PER_BYTE else nonceTrialsPerByte
@Suppress("NAME_SHADOWING")
@@ -181,12 +194,16 @@ abstract class AbstractCryptography protected constructor(@JvmField protected va
}
override fun createPubkey(version: Long, stream: Long, privateSigningKey: ByteArray, privateEncryptionKey: ByteArray,
nonceTrialsPerByte: Long, extraBytes: Long, vararg features: Pubkey.Feature): Pubkey {
return Factory.createPubkey(version, stream,
override fun createPubkey(
version: Long, stream: Long, privateSigningKey: ByteArray, privateEncryptionKey: ByteArray,
nonceTrialsPerByte: Long, extraBytes: Long, vararg features: Pubkey.Feature
): Pubkey {
return Factory.createPubkey(
version, stream,
createPublicKey(privateSigningKey),
createPublicKey(privateEncryptionKey),
nonceTrialsPerByte, extraBytes, *features)
nonceTrialsPerByte, extraBytes, *features
)
}
override fun keyToBigInt(privateKey: ByteArray): BigInteger {