Nim is a compiled, garbage-collected systems programming language which has an excellent productivity/performance ratio. Nim's design focuses on efficiency, expressiveness, elegance (in the order of priority).
strenc is really fragile, it's just a poc
sure it is, in fact I'd like to use it for just a couple if strings, not the whole project
I'm not sure why it got so much attention, because it really doesn't work well, and I don't know how to make it work well :)
I think you'd want to write some other code then, you don't need term rewriting for that
You can just have a template or macro that encrypts the string at compile time and decrypts at runtime, and call it explicitly
yes, I started from strenc because I liked the simple idea of rolling enc linked to built time. I should probably go nimcrypt, but I'm now experienced in encryption in general
the key is still on the binary
its as encryption as base64 is
yes yes I know, I just want to hide from kids
and also play around this, just because of nim
I yet have to find a proper use of compile time magic
well technically it is encryption if you didn't know the xor key :) but it can be easily bruteforced, yes
yes, in strenc case, but xor encryption itself is different from base-n
anywhere else yes its encryption
Well, as I said you can easily create your own strenc with encryption for specific strings
sure I'm going that direction, also pulling in nimcrypto as I've never used it before and seems solid
no, just out of personal interest
yeah, i know that term-rewriting macros have a lot of issues
they might be even removed in the future
I'm unwrapping strenc into manual mode
--passL:"-static" in your project.nims
there are multiple ways actually
tried , but didn't link together
Hey guys, any patterns you use for
I move the whole main loop into an
--dry-run or other options which are frequently-checked but permanent for all the running time of your program?I move the whole main loop into an
fooImpl template with a bool parameter and instantiate a proc based on the user settings. Is there a reason I should not do it? I understand the implications of having multiple such options in a template, of course :D
not sure I understood your question, but can't you just parse user configuration into some object initially, and then just pass that object around?
it'll be pretty efficient and easy to use
Yardanico: I've converted the term rewriting macro into a simple macro and I'm encrypting the result of a staticRead. I'm compiling with --d:release and --passL:-s, but "stings mylib.so | grep contents" results in perfectly readable stuff
first of all, if you have a
const string nim will decrypt it at compile time anyway
and then the C compiler might also try to do a similar thing
well, that's what's happening probably. The only changed line from your code is the signature: macro encrypt*(s: static[string]): untyped =
import std/[macros, hashes]
# Use a "strange" name
proc gkkaekgaEE(s: string, key: int): string {.noinline.} =
# We need {.noinline.} here because otherwise C compiler
# aggresively inlines this procedure for EACH string which results
# in more assembly instructions
var k = key
result = s
for i in 0 ..< result.len:
for f in [0, 8, 16, 24]:
result[i] = chr(uint8(result[i]) xor uint8((k shr f) and 0xFF))
k = k +% 1
var encodedCounter {.compileTime.} = hash(CompileTime & CompileDate) and 0x7FFFFFFF
macro enc*(s: string): untyped =
var encodedStr = gkkaekgaEE($s, encodedCounter)
result = quote do:
gkkaekgaEE(`encodedStr`, `encodedCounter`)
encodedCounter = (encodedCounter *% 16777619) and 0x7FFFFFFF
let testStr = enc("hello world!")
echo testStr
obviously your string has to be
var or let, otherwise it'll be decrypted at compile-time
and yeah, you can change the macro arg to static[string], that won't hurt
found my error while you were typing. I has the equivalent of "const testStr = enc("hello world!")", so compiler was running symmetric crypt function twice at compile time
this is when compiling with arc - the C code simply references the encoded string and the xor decryption key to it, and assings the result to the variable
which is then assigned to
testStr and fed to echo, then destroyed