#social 2018-07-12
2018-07-12 UTC
timbl, tantek and up201705417 joined the channel
# 
dansup I just checked, pixelfed is using the proper format like mastodon :)
# dansup "when in doubt or not covered by the spec, do what mastodon does"
# dansup thats what I was told by a few other developers
# 
Loqi [Christopher Lemmer Webber] I wonder if a Pleroma hacker such as @lain or @kaniini have any info about how their keys are being generated and rendered in PEM format? https://github.com/w3c/activitypub/issues/315
up201705417 joined the channel
# 
cwebber2 http://luca.ntop.org/Teaching/Appunti/asn1.html is dramatically outdated, by 25 years, but even 25y ago you can see how complicated that shit was
# nightpool[m] re: monoculture stuff, like I said a couple times—we had no idea this would even be a problem because ruby openssl parses both formats transparently.
# nightpool[m] I'm pretty sure most people wouldn't even know there are multiple formats you can use with PEM encoding
# nightpool[m] the web payments guys apparently didn't (or didn't care)
# nightpool[m] well i mean
# nightpool[m] we had like 4
# nightpool[m] c#, elixer, ruby, and a couple other small ones
# nightpool[m] noone ran into this problem
# nightpool[m] not particularly
# nightpool[m] i think this is just a relatively surprising behavior by one stdlib
up201705417 joined the channel
# nightpool[m] oh, racket was having a problem also?
# nightpool[m] yeah i dunno
# nightpool[m] there's lots of weird semi-monoculture stuff in our activity implementations
# nightpool[m] but i dont think this is one of them
# kaniini hi
# kaniini cwebber2, aaronpk, nightpool[m] pleroma presently use pkcs#1, but i am changing it to x509.
# kaniini aaronpk yes, it is the default preference for erlang public keys
# kaniini if you manually specify SubjectPublicKeyInfo instead of RSAPublicKey, you will get x509 key instead.
# cwebber2 looks at https://tools.ietf.org/html/rfc8017 and sees lambda and briefly fears that pkcs#1 is turing complete
ben_thatmustbeme joined the channel
# dansup heh
# kaniini i suspect that may be the interop problem we have with misskey too.
# kaniini some node.js versions hate pleroma
# kaniini aaronpk please try https://pleroma.dereferenced.org/users/kaniini with application/ld+json; profile=...
# nightpool[m] (https://pleroma.dereferenced.org/users/kaniini.activity+json :D)
# kaniini that works too yes
# kaniini ok
# kaniini aaronpk is that webfinger enabled
# kaniini yes, it is
# kaniini aaronpk seems to work, my server accepted your http signature
# kaniini i don't see any likes
# kaniini but i assume your implementation was able to decode my key
# kaniini pleroma has certain Opinions(tm) about activitypub, so they might not clash well with what your impl wants
# kaniini hmm
# kaniini on what uri
# kaniini that's not the real uri
# kaniini but should probably 302 to the real uri for the activity
# kaniini hum
# kaniini it used to
# kaniini idk why it quit working
# kaniini but usually stuff is like
# kaniini https://.../activities/uuid
# kaniini we're trying to phase out the gnu social urls
# kaniini no, it should work
# kaniini let me look into it
# kaniini but can you decode the key i am sending as publicKeyPem now?
# kaniini i just want to make sure that's good
# nightpool[m] and it only uses the activities stuff for the URI
# nightpool[m] so most people see the notice routes
# kaniini nightpool[m] in pleroma FE, yes. in mastodon FE, we use the activity uri now
# kaniini notice urls are being deprecated when pleroma FE goes to native ap c2s
# kaniini that one should work :)
# nightpool[m] mmm. i can only speak for what I see from pleroma's activities
# nightpool[m] url as notice, id as object
# kaniini if you use a browser yes :)
# kaniini you can also put .activity+json at the end of it
# kaniini but
# kaniini notice urls should work too
# kaniini looking into it...
# kaniini url property on which
# kaniini that's an AS2 object
# kaniini i don't think mastodon sends an url property there
# nightpool[m] uploaded an image: image.png (202KB) <https://matrix.cybre.space/_matrix/media/v1/download/cybre.space/BppTCxvIJVfxuLqvWfhleduy>
# kaniini ah i see it
# kaniini i can add it, but it's not required by AS2
# kaniini so i wouldn't depend on it
# kaniini (to my knowledge anyway)
# kaniini ok
# kaniini pleroma also does not implement json-ld at present
DenSchub joined the channel
# tuxether[m] are inbox and outbox in-memory data structures?
# tuxether[m] I'm using with the go-fed library in golang which seems to use in-memory representations. Do other implementations do the same?
# tuxether[m] So it's okay to read from a SQL database and use the inbox/outbox only to read/write to the database?
# tuxether[m] ok. That clears things up. I just wasn't sure. I don't think the spec particularly ruled out databases.
DenSchub_, xmpp-social and vasilakisfil joined the channel
# puckipedia ok, Kroeg now has authorization
# fr33domlover thinks JSON-LD is horrible and wishes AP and AS2 just worked over plain RDF
# fr33domlover also thinks the JSON-LD spec itself is horrible and wonders how it was even accepted
# fr33domlover (especially the API part)
timbl joined the channel
# 
jaywink[m] can someone explain in plain english what is the benefit of even trying to implement JSON-LD? AFAICT AP can be done by just working with JSON. while implementing, is there actual benefit of trying to go the hard route of json-ld?
# puckipedia jaywink[m]: for me primarily: extensions, better resilience against wonky objects
# puckipedia any incoming objects into kroeg get translated into node maps, which are then used
# fr33domlover Why was JSON-LD even chosen for AS2 / AP ?
# fr33domlover They could choose something that is more like plain RDF
# fr33domlover It's simpler, established, lots of software support
# puckipedia they chose /compacted/ json-ld which is close to just being JSON
# fr33domlover puckipedia, yeah but that's just for the core vocabulary :-/ I don't like this closed world feeling
# puckipedia and yeah I internally use stuff that is pretty close to RDF because it's easier to process safely
# fr33domlover Not to underestimate people's effort, but I feel like I suffer the most because I'm implementing JSON-LD in Haskell which is a functional language and strongly typed. And the JSON-LD is waaaaay too much JS biased and it makes it a nightmare for me
# puckipedia looks at her jsonld implementation in rust
# fr33domlover *the JSON-LD API spec
# tuxether[m] JSON-LD in any strongly typed language would be hard, not just Haskell.
# puckipedia and yeah, the API assumes js objects, which is slightly disappointing
# fr33domlover tuxether[m], yeah I agree
# puckipedia it's not /impossible/ though
# fr33domlover tuxether[m], but it's because the spec is written based on JS code (or thoughts of a person who thinks in terms of JS code)
# fr33domlover It would have been written with types of stuff specified properly
# fr33domlover IMHO it should have been because it's a specification
# fr33domlover It should be accurate
# fr33domlover Even if the JS implementation of digital bazaar isn't
# fr33domlover (it's their problem, not ours... why do we need to suffer :p)
# tuxether[m] Because we're a small group. The haskell userbase is only recently growing.
# fr33domlover tuxether[m], I mean we as in everyone in the world except for digital bazaar :p
# fr33domlover (or people who rely on their JS implementation)
# puckipedia the node map that is primarily meant as "internal" structure is really useful as entity representation
# fr33domlover At some point I considerd to implement JSON-LD in Haskell using a plain JSON object type and nothing more, and just emulate the spec's imperative style
# fr33domlover But it makes me want to cry,
# fr33domlover THe thought of Haskell code written like that
# puckipedia the rust code uses a "json" enum which looks like, approx
# puckipedia enum Value
{ Object(Map<String, Value>), Array(Vec<Value>), Number(..), Boolean(..), String(..), ... }# fr33domlover So I'm pushing through a properly typed version and purely functional style by default
# fr33domlover puckipedia, yeah Haskell has such a type in aeson, the most popular JSON library
# fr33domlover Another problem though, is that if you use that type all along, the code is error prone / errors can detected late
# tuxether[m] I agree. Haskell code needs to look beautiful. But I'm surprised no one has done JSON-LD.
# fr33domlover tuxether[m], people thought about it but guess what
# puckipedia fr33domlover: this is /complicated/
# fr33domlover the person eventually used JS code the project
# fr33domlover so they didn't need it in Haskell :p
# tuxether[m] Does aeson-ld not work?
# puckipedia fr33domlover: I assume you mean ensuring that the incoming structure is already properly structured?
# fr33domlover tuxether[m], people often do frontend in non Haskell languages etc.
# fr33domlover and then they end up not needing JSON-LD in Haskell
# fr33domlover puckipedia, I mean that the ensuring causes a runtime error; proper typing catches it as build time
# fr33domlover When possible
# puckipedia it isn't that difficult to create a typing structure for expanded JSON-LD, contexts, and node maps
# tuxether[m] looks at aeson-ld source code. disappointed
# puckipedia yeah same
# tuxether[m] fr33domlover: I'm sure there's people on the Haskell IRC who would like something to do :)
# fr33domlover tuxether[m], I'm already working on this :)
# puckipedia this kind of thing (where a completely empty repo exists) is why I don't publish my code until it's far enough :<
# tuxether[m] so, is the Haskell activitypub implementation going to be a server or a library?
# tuxether[m] I was thinking of bootstrapping AP in haskell, and thought a library doing templateHaskell could ease the burden of writing AP/AS code
# tuxether[m] don't have time to do it right now, sadly. Getting an AP server up in golang
# fr33domlover is doing AP in Haskell
# fr33domlover (ActivityPub)
# tuxether[m] understood, but is there a plan to factor out the AP bits into a reusable library?
# fr33domlover tuxether[m], yes :)
# tuxether[m] fr33domlover: awesome!
# puckipedia Kroeg's rust code is also meant to be easily reusable lol
# fr33domlover :)
# puckipedia the entity store is separate and meant to be easily replacable, the activitypub-related entity handlers are implemented in a separate module from the rest of the code
# puckipedia so someone could e.g. extend kroeg by writing a new rust crate, then letting the server depend on it + list the handlers
# fr33domlover tuxether[m], I'm writing a Yesod web app, so, it's going to be whatever piece is generally reusable, and then Yesod wrappers, and then perhaps even some subsite/utilities including DB models for adding AP to a yesod web app
# tuxether[m] kroeg on github is C# ?
# fr33domlover I'll modularize everything I can (I generally do that as I go)
# tuxether[m] fr33domlover: in golang there's the go-fed library which aims to be fully spec compliant but not bother with implementation.
# fr33domlover tuxether[m], yeah I saw. But doesn't Go already have a JSON-LD implementation?
# fr33domlover So go-fed could just use it
# tuxether[m] yes, it does. somewhere.
# fr33domlover tuxether[m], json-ld.org links to it
# puckipedia tuxether[m]: yeah, odler version
# puckipedia older(
# puckipedia that one has been put on hold
# fr33domlover I'm splitting my JSON-LD lib into one with fully typed node objects, and another one that parses those objects from a plain JSON object. Any HTTP client lib and any JSON parser/encoder can be plugged in that way
# fr33domlover When I finish this I will become a saint
# fr33domlover You can then call me St. fr33domlover
# fr33domlover (tbh even then I'll minimize my use of JSON-LD because it's so scary and error prone and people rarely implement by the spec because it's abiguous and disagrees with tests and with the original JS impl... not exactly the kind of format/spec you want to rely on for the long term)
# tuxether[m] correct me if I'm wrong. Isn't JSON-LD optional?
# fr33domlover tuxether[m], in plain AP? Yes. But I need extensions and I want freedom to work with RDF. So I'm gonna convert all the JSON-LD to RDF, work with RDF, convert to JSON-LD, compact it and throw it into the HTTP responses
# fr33domlover I want my code to be relevant for the long term and work with actual generic linked data
# fr33domlover Not those very very specific JSON structures
KjetilK_, cwebber2 and timbl joined the channel
# dansup up201705417: Congrats on the first big step for GNU/Social AP support!
# up201705417 thx! :) (for some context: https://loadaverage.org/notice/13330474 )
fr33domlover and fr33domlover1 joined the channel
# cwebber2 kaniini: I'm really worried about this https://pleroma.site/objects/906f234d-7d15-4a80-9852-1be81b86c1f2
# kaniini what do you mean
# kaniini AP has the privacy attributes of email
# nightpool[m] most people would feel comfortable emailing their dick pics
# nightpool[m] to adopt your metaphor
# jaywink[m] you can end to end encrypt. that is all
# kaniini if you want true privacy, OMEMO extension is the way to go, and adopting Zot-style security model for attachments
# kaniini but i don't think people should email dick pics either
# kaniini to continue with the metaphor :)
# kaniini i didn't use the word 'malicious' for a reason :)
# kaniini cwebber2 feature discovery would be nice
# jaywink[m] Zot style permissions wont help if the server admin is malicious and looks at your pics
# kaniini jaywink[m] it won't, that is true :)
# kaniini cwebber2 the problem is people have different expectations of email vs social networking
# kaniini historically, facebook has kept your info 100% safe
# kaniini (this is the perception, not the reality)
# kaniini most believe, because of facebook keeping your info locked up, that other platforms do as well
# kaniini which is why everyone is always shocked that a non-conformant implementation might leak their data
# kaniini this isn't a problem of the activitypub protocol itself
# kaniini i mean, bluntly, like i don't want people to email their dick pics, i don't want people to use activitypub to spread their dick pics either
# kaniini okay, 'privacy-crucial data'
# kaniini so the question becomes
# kaniini is activitypub meant to be a WebMTA
# kaniini or is it meant to be more than that
# kaniini personally, i think activitypub is in the right spot right now. with native AP C2S, an EncryptedEnvelope object type could be added to do something like PGP for people who want that
# kaniini at least, this is my plan in pleroma 2
# kaniini the problem is
# kaniini people assume privacy == end-to-end encryption
# kaniini yes, to/cc fields are a form of 'privacy' too, but it is not the 'privacy' that your average person associates with the word 'privacy'
# kaniini so, we need to remind people that it is not E2E
# kaniini that's what the warning is about :)
# kaniini cwebber2 it is also important to note that people have already modified both pleroma and mastodon to leak messages publicly
# kaniini which is why pleroma has gained quarantine mode
# kaniini quarantine mode = never send anything that isn't addressed to https://www.w3.org/ns/activitystreams#Public to this server
Guest62Dan joined the channel
# Guest62Dan I think I have done a garbage job at connecting to this chat but I was watching the logs at the time and I feel like there is not a need for new Objects to cover end to end encryption
# Guest62Dan we have contentType which can be pgp-encrypted or multipart encrypted and then the content string can contain encrypted data
# kaniini Guest62Dan what if you want to encrypt the metadata too
# kaniini :)
# Guest62Dan Wrap it in an object
# Guest62Dan contentType json+ld
# kaniini congrats, you just reinvented EncryptedEnvelope from first principles
# kaniini ;)
# jaywink[m] btw, has anyone seen microblog.pub? haven't seen it mentioned here. It's a Python based single user AP server - https://github.com/tsileo/microblog.pub .. the AP code looks good and is in its own repo: https://github.com/tsileo/little-boxes
# Guest62Dan I am confused as to why it needs a name though
# Guest62Dan Doesnt that require muddling about with extensions?
# kaniini Guest62Dan in my case, it needs a name because i do not implement json-ld
# Guest62Dan You implement json though
# kaniini i would rather not go into the exact details as to why that is, because it is not productive, but we will just have to agree to disagree on it
fr33domlover1 joined the channel
# Guest62Dan I mean we could also talk about it but if you don't want to that is ok too
# kaniini aaronpk well
# kaniini we do some "json-ld" like stuff
# kaniini for example, we know how to dereference IRIs
# kaniini but
# kaniini turning the json into an rdf object and all of that stuff, if it ever becomes a hard requirement, i hear zot6 is nice :)
# kaniini i mean, i understand this is a w3c production, and due to politics semantic web crap has to be shoved into everything, but i can pretend it doesn't exist right now :P
# kaniini i guess it is better than standardizing at IETF these days
# kaniini activitypub at IETF would turn into some variation of RADIUS or something whack like that probably
# jaywink[m] kaniini++ for giving a laught and making me more confident I don't have to ever open the json-ld spec :P
# kaniini in fact
# kaniini if there is somebody at W3C i can just go get super drunk
# kaniini and he will be like
# kaniini JSON-LD removed from ActivityPub? done!
# kaniini please, just let me know now
# kaniini i will get it done
# Guest62Dan I mean the spec doesn't require it. It is just an option for defining ontological extensions
# puckipedia kaniini: btw, the like_count / likes thing in your activitypub representations makes kroeg unhappy
# dansup puckipedia: Why is that?
# puckipedia because kroeg parses it as "_:like_count" which gets discarded, and as:likes which should be a collection, and instead now is a set of users which will then be tried to be parsed as collections
# dansup Ah I see, so this probably isn't a good idea either? https://github.com/dansup/pixelfed/blob/dev/app/Transformer/ActivityPub/ProfileTransformer.php#L27-L28
# puckipedia i'm not going to complain about it, but mastodon won't like it either
# puckipedia you can create a collection stub by replacing it with a /followers object which is just
{"totalItems": 4}# dansup ok, thanks!
# puckipedia like, it won't conflict with anything, it also won't show up in most other things
# kaniini puckipedia that is internal-representation being leaked out
fr33domlover and fr33domlover1 joined the channel
# Gargron every HN thread about something fediverse-related there is the same person pushing forward Movim
# jaywink[m] XMPP is still fighting on 😁
fr33domlover1 and vasilakisfil joined the channel