weez17 has quit [Remote host closed the connection]
weez17 has joined #ipfs
bingo has joined #ipfs
ashark has quit [Ping timeout: 240 seconds]
<MikeFair>
Powersource, If what you're suggesting is that any IPNS Key should be able to Root an MFS file store then I agree with you
<MikeFair>
You'd probably need a way to register the keys with an ipfs daemon so it could take responsibility for the path's namespace
<MikeFair>
On think I'm not clear on though is how does one get an entry in the dapps pathspace?
<Powersource>
MikeFair: I don't think we're talking about the same thing. I'm saying that siteA.com shouldn't be able to edit the IPNS-addresses of siteB.com, even if the same user and daemon is visiting both
<MikeFair>
If siteA.com has the private key to the IPNS addresses, then why not
<Powersource>
MikeFair: well they'
<Powersource>
they'd have it by default since the daemon/companion don't namespace it
goiko has quit [Ping timeout: 265 seconds]
<MikeFair>
siteB.com would have siteA.com's private key?
<Powersource>
i'm not saying anyone has anyone's private key. It'd be enough for one site's JS to call ipfs.name.publish(address-published-by-other-site) to overwrite it
<MikeFair>
You can't publish if you don't have the private key because you can't construct a properly form update record
<MikeFair>
The IPFS daemons will reject the request
<MikeFair>
If you do have the private key on the other hand, then you can do exactly what you're saying
<Powersource>
you don't need any keys with the new window.ipfs api
<MikeFair>
To update an IPNS entry?
<MikeFair>
I thought it was that IPNS updates simply aren't supported
DJ-AN0N has quit [Quit: DJ-AN0N]
<MikeFair>
Sounds like I really need to read more on how it works :)
<Powersource>
thanks, that might answer my question, aren't they?
<MikeFair>
They weren't last I checked; but that was a while back
goiko has joined #ipfs
<MikeFair>
ipfs.name.publish just wasn't something you could call
<MikeFair>
and when you do call publish, and identify a custom key, then you identify the private key of the IPNS entry
<MikeFair>
Well I guess the expection is the IPNS entry that is the IPNS of your daemon's noe
<MikeFair>
node
<MikeFair>
that's a "default" and you don't specify a private key for that because the daemon has its own key already
<MikeFair>
I rarely ever use it because it's not "fixed enough" for my taste
<MikeFair>
I don't want an IPNS address that's linked to my daemon's instance; that gets destroyed, rebuilt, moved, re-initialized all the time
ashark has joined #ipfs
<MikeFair>
I make new named keys to represent the "root" of the IPNS volume (usually named for the domain published using them)
<MikeFair>
Powersource, Okay, this helps clarify a bit: This add-on enables everyone to access IPFS resources the way they were meant: from locally running IPFS node :-)
<MikeFair>
This means unless you specify an alternate private key, ipfs.name.publish is requesting to update local node's IPNS entry (the daemon running on your own machine)
ashark has quit [Ping timeout: 240 seconds]
<MikeFair>
And unless you're sitting on the daemon that controls "siteA.com" you can't modify "siteA.com"'s IPNS pointer
bingo has quit [Remote host closed the connection]
bingo has joined #ipfs
daMaestro has joined #ipfs
<petersjt014[m]>
anyone know if fs-migrate is available under gx, and if so where I might find the hash?
bingo has quit [Ping timeout: 240 seconds]
nicu has quit [Remote host closed the connection]
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<petersjt014[m]>
I tried using [this](http://mars.i.ipfs.team:9444/) page but got "incorrectly formatted lastpubver in repo
<petersjt014[m]>
"
MikeFair has quit [Ping timeout: 245 seconds]
MikeFair has joined #ipfs
pcardune has quit [Remote host closed the connection]
unchipped has quit [Remote host closed the connection]
trn has quit [Excess Flood]
ericxtang has quit [Remote host closed the connection]
<MikeFair>
Does IPFS jave any "personal identity" type features yet?
pcardune has joined #ipfs
<MikeFair>
Specifically something where people could share encrypted data with each other
<whyrusleeping>
MikeFair: not yet, hasnt been a focus yet
Alobar has quit [Ping timeout: 260 seconds]
<whyrusleeping>
its a pretty tricky problem too
<MikeFair>
Didn't think so
<MikeFair>
it is
bingo has quit [Remote host closed the connection]
<MikeFair>
Mostly I think it's requires a social solution to solve the "hard bits"
bingo has joined #ipfs
<underikar>
I'm wondering if it's a good idea (at least in the meantime) to use https for the personal account kind of stuff
<MikeFair>
Something like CACert; and KYC signature proofs, etc
<underikar>
(for whatever can't be hosted locally)
<MikeFair>
I'm exploring a few different options; the service I'm making requires your personal bank account info
<MikeFair>
It then links that with a public key identity
<MikeFair>
I don't want to make the link deterministic because bank account information simply doesn't have enough entropy to it
The_8472 has quit [Ping timeout: 240 seconds]
pcardune has quit [Ping timeout: 260 seconds]
<MikeFair>
The "last mile" of the service needs to take the messages you've signed and submitted and put your actual bank account details on the record before sending it on
bingo has quit [Ping timeout: 263 seconds]
<MikeFair>
Would love to have some trustworthy mechanism where the user (you) were able to authorize/deauthorize the service
<MikeFair>
But the problem is that decryption methods don't really have "time bounds"
<MikeFair>
If for example the cypherText was stored in IPFS, then eventually the decryption method/key for that cypherText would get compromised
<MikeFair>
whyrusleeping, Have you are anyone you've spoken to mused on creating a "rotating" cypherText? This test would be the absolute antithesis of immutability
<MikeFair>
test = text = data
The_8472 has joined #ipfs
peterix has joined #ipfs
mog- has joined #ipfs
pvh has quit [Quit: Connection closed for inactivity]
mog has quit [Ping timeout: 265 seconds]
mog- is now known as mog
pcardune has joined #ipfs
chriscool1 has joined #ipfs
ericxtang has joined #ipfs
ericxtang has quit [Remote host closed the connection]
<petersjt014[m]>
MikeFair: you mean one where the correct key changes?
<MikeFair>
petersjt014[m], Yes, something like that
<MikeFair>
Something where the data retrieved by "ADDRESS" requires non-deterministic information to read
<petersjt014[m]>
That's probably a really hard problem, if possible
<petersjt014[m]>
if you want to change the key, you need to decrypt the ciphertext first
<MikeFair>
Well the only systems I can think of to do it have a lot of trust involved
<petersjt014[m]>
wait
<petersjt014[m]>
there is one other thing
<MikeFair>
petersjt014[m], Well I was thinking you could 'reencrypt with the next key' and then combine multiple secret keys together
<MikeFair>
Okay, the use case I'm starting with is KYC personal information
<petersjt014[m]>
there's gotta be a way to do this w/o smart contracts or something...
<MikeFair>
Well I'm looking at some of the "axioms"
<MikeFair>
If I give you the cypherText, and the key; that's totally deterministic
<MikeFair>
if cypherText is in a public place, and you publish the key I gave you, then all-my-info-are-belong-to-everyone
<MikeFair>
that's kind of my "test case"
<petersjt014[m]>
I think I might have a way to change the key securely
<MikeFair>
OH!! Maybe instead of publishing the data; I publish a rotating one time pad
<MikeFair>
the "key" I send you is then how to read my data out of the pad
<petersjt014[m]>
OTPs over the internet are usually not a good idea.
<MikeFair>
Sorry; please ; let's hear the thoughts?
<petersjt014[m]>
I'll get to my idea, but first:
<MikeFair>
I'm thinking I publish code that is a PRNG
<petersjt014[m]>
OTPs are perfectly theoretically secure
<MikeFair>
Yeah; I've mused about them a lot; communicating the pad is always the problem
<petersjt014[m]>
the better securely held the key, the better the security
<petersjt014[m]>
if you have 100% confidence the key'll be properly transported, your message is perfectly secure--in practice AND in theory
<petersjt014[m]>
the problem is that everything else is less secure
<petersjt014[m]>
using a strong weak cipher to transfer the key to a stronger one is counterproductive at best
<petersjt014[m]>
(typo: ignore that 1st 'strong')
<MikeFair>
right
<petersjt014[m]>
one really weird thing about that
<MikeFair>
For example I know that I can encrypt using my own secret key then encrypt using your public key and only you can read the data and you can validate it came from me
<petersjt014[m]>
relying on people (the least secure part of cryptography) can result in perfect secrecy.
<MikeFair>
Using Asymmetric encryption
<petersjt014[m]>
yeah, pgp is dual-pronged like that
<MikeFair>
I agree, I formalized it as due to the non-deterministic nature of the human
<MikeFair>
In this case; there is no "human in the middle"; they can "set it up" but then it just runs
<MikeFair>
I do have a bit of a "solution looking for a problem" for a common public entropy source
<petersjt014[m]>
one common one I see is the latest hash of the bitcoin blockchain
<petersjt014[m]>
since the hash can't be known ahead of time
<MikeFair>
using the ledger/block checksums from a blockchain network; they are a public; easily accessible; unpredictable; source of entropy that can't be known until the time it's produced
<MikeFair>
hehe
<petersjt014[m]>
they work for ensuring "no later than"
<MikeFair>
I proposed it as the seed for the PRNG in producing lottery results
<petersjt014[m]>
"no earlier than" im less sure of
<MikeFair>
No earlier than is "secure in practice" but you can dream up theoretical situations where they aren't secure like ("You lock everyone out of the network so that you can fully control the transactions; you precompute the outcomes for a special transaction and submit it)
<MikeFair>
But the problem is since I can't predict it in advance; then I can't use the information
<MikeFair>
But if I used my PRNG/published OTP idea
user51 has joined #ipfs
<MikeFair>
How about something like this: I publish the 32 byte seed for a PRNG in a known place
<MikeFair>
the system combines that with the last hash to make a new key
<MikeFair>
nm; I can't seem to get there from here ;)
<MikeFair>
The main question I'm grabbling with is what can you possibly share
<MikeFair>
in a public way
DO1MB has quit [Ping timeout: 268 seconds]
<MikeFair>
I keep coming up with "whatever it is, the public version of it needs to be on a non-determinstic frequency hopping algorithm that you know"
<petersjt014[m]>
so to be clear: you want the ability to have "expiring" keys, right?
<MikeFair>
more like; revokable
ericxtang has joined #ipfs
<petersjt014[m]>
I think I have a way to do that
<MikeFair>
And more generally; I want you to be able to decrypt the data today; but not tomorrow; and the real kicker is the plainText unfortunately doesn't change in my use case; so I'm "trusting" that you dump it after each use
<MikeFair>
We are both more concerned about a third party getting the plainText than whether or not you can continue to read it
<MikeFair>
And I really hope that it has "forward secrecy" so a compromise of tomorrow's key doesn't give you access to today's key
<petersjt014[m]>
my idea isn't quite capable of that, but It might lead somewhere
<MikeFair>
I'm not sure if anything is capable of that :)
<petersjt014[m]>
here's a rundown:
<petersjt014[m]>
the plaintext is encrypted with Alice's key, and the ciphertext may be freely distributed
<petersjt014[m]>
the key can manually be revoked, but only a limited number of times
<MikeFair>
Alice's Public Key? so it can only be rad by Alice's secret key
<petersjt014[m]>
yeah
ericxtang has quit [Ping timeout: 264 seconds]
<MikeFair>
Is "limited number" controllable?
<MikeFair>
Sorry
<MikeFair>
keep going
<MikeFair>
it sounds like something
<petersjt014[m]>
Yes, it is. The method of revoking keys involves hashing
<petersjt014[m]>
but instead of hashing the key to get a new one, you unhash it
<petersjt014[m]>
:}
<petersjt014[m]>
obviously that's impossible--it's a trapdoor function after all
<MikeFair>
Okay, so I make myself KeyPair, I keep my secret key secret, publish my Public Key, I then create a symmetric key and encrypt my home address with it; I then encrypt the message "symmetric, home cyphertext" with the public key
zautomata2 has quit [Ping timeout: 264 seconds]
<petersjt014[m]>
sort of
<MikeFair>
I scrambled the home address first to get perfect secrecy
<MikeFair>
(I know I added that extra step to my plainText)
<MikeFair>
My plainText in this case is my name, home address, SSN, and routing/bank account numbers
<petersjt014[m]>
to quick finish up mine though:
<petersjt014[m]>
the key is based on an initial seed which is hashed _n_ times, giving _n_ possible revokations
<MikeFair>
Yeah Yeah; I was thinking something along these lines
<petersjt014[m]>
e.x. if the seed is hashed 50 times, the 50th is used first
<MikeFair>
PBKDF2 on the key where the number of "rounds" is unknown and goes down
<petersjt014[m]>
it's deterministic, but unpredictable
<MikeFair>
okay keep going
<MikeFair>
Let's assume I used 1,000,000 rounds
<MikeFair>
:)
<petersjt014[m]>
the idea then is that the plaintext is re-encrypted and published using the new key
<petersjt014[m]>
if the former key is not leaked, then the info stays secure
<petersjt014[m]>
and the ratchet property of the key determination technique ensures that newer keys cannot be used to derive older ones
<petersjt014[m]>
(though might not matter if the plaintext remains the same)
<MikeFair>
Not the plainText, but the published cyherText right?
<petersjt014[m]>
what about it?
<MikeFair>
That's what gets re-encrypted
hph^ has joined #ipfs
<petersjt014[m]>
maybe. that that'd get unwieldy fast, but it'd work
<petersjt014[m]>
and technically the key is changed because it now is made of n+1 keys
<MikeFair>
If I re-encrypt the plainText and republish it; then I might as well just invent an entirely new non-determinstic key
<petersjt014[m]>
but a simpler solution would be reencrypting the plaintext
<petersjt014[m]>
maybe
<MikeFair>
I was looking for a way for the system, like IPFS to auto-transform the cypherText without reveling the plainText
<petersjt014[m]>
but the deterministic nature is an advantage
<petersjt014[m]>
as long as part of the key is unknown
<petersjt014[m]>
(ideally a large part)
<MikeFair>
I could use the list of hashes as a source for an OTP of sorts; and then keep the "which hash" and "how many round" as the secrets; but it seems no different than just keeping a secret in the first place
<petersjt014[m]>
for that list, you already would have the hashchain option available
<MikeFair>
I am finding myself looking at that first thought I had to encrypt my Info with a symmetric key; then encrypt the symmetric key + cypherText together as the PlainText of the message
<petersjt014[m]>
then you could use the next in succession, and use a homomorphic cipher to reencrypt the ciphertext w/o exposing the plaintext
<MikeFair>
petersjt014[m], I'm kind of thinking something like that
<MikeFair>
Let's say for a moment I break my message up into 32-bit segments
<MikeFair>
I then pair each segment with a 32-bit symmetric key and xor them
<MikeFair>
The 32-bit key + xor value = 64-bit cypherText
<MikeFair>
and there's a long string of those
<MikeFair>
to be my original message
jesse22_ has quit [Ping timeout: 276 seconds]
<MikeFair>
What I'm thinking of here is that I can operate on the key/message to maintain the integrity of the message
<MikeFair>
It just feels like if I do I'm leaking information
<MikeFair>
about the plainText
<petersjt014[m]>
xor's nice for combining values to make new ones (eg keys) without needing to worry about the order
<petersjt014[m]>
by itself it's not too secure
<petersjt014[m]>
I gotta go for like 10min, but one other idea before that
<petersjt014[m]>
it might not allow for an ideal solution, but it could come close
<petersjt014[m]>
the one thing I know of that uses sharding in a very effective way is in siacoin
<petersjt014[m]>
their sharding involves intermixing the ciphertext fragments from multiple plaintext fragments
<petersjt014[m]>
it'd still be possible to pin down which originate from where, but it'd get harder the larger the network
hph^ has quit [Ping timeout: 265 seconds]
<MikeFair>
How would my service provider read the data though
<petersjt014[m]>
but then even if a shard's key is leaked, it's difficult to pin down which ciphertext fragment it belongs to
<MikeFair>
Let's use a somewhat innocuous plainText like my phone number
<petersjt014[m]>
I'm basing this off [siacoin's](https://sia.tech) method of sharding, so their whitepaper might have that answer
<MikeFair>
We are going to use our respective IPNS keys as 'phone number proxies'
hph^ has joined #ipfs
<MikeFair>
I make a phone call by saying from "my IPNS" to "your IPNS"
<MikeFair>
Phone Service Provider gets that and now needs to translate our IPNS keys into phone numbers
<MikeFair>
ideally what's happened is we've encrypted our phone number data and put it in the CID pointed to by the IPNS entry
<MikeFair>
The Phone Service System now needs to be able to read that phone number out to place the call
<MikeFair>
and put my caller id on your phone (for example)
<MikeFair>
Once Phone Service Provider no longer needs the phone numbers it is trusted to delete them
<petersjt014[m]>
brb in 10 mins
<MikeFair>
(the plainText is forgotten)
<MikeFair>
sounds good :)
jesse22 has joined #ipfs
ericxtang has joined #ipfs
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
colatkinson has joined #ipfs
Q5I895tekk has joined #ipfs
Q5I895tekk has quit [Remote host closed the connection]
jesse22 has joined #ipfs
sz0 has quit [Quit: Connection closed for inactivity]
<petersjt014[m]>
back
hph^ has quit [Ping timeout: 240 seconds]
moetunesZ1SCB1 has joined #ipfs
moetunesZ1SCB1 has quit [Remote host closed the connection]
MikeFair has quit [Ping timeout: 276 seconds]
colatkinson has quit [Ping timeout: 240 seconds]
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jesse22 has joined #ipfs
lord| has quit [Ping timeout: 240 seconds]
lord| has joined #ipfs
daMaestro has quit [Quit: Leaving]
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jesse22 has joined #ipfs
pcardune has quit [Remote host closed the connection]
pcardune has joined #ipfs
ericxtang has quit [Remote host closed the connection]
infinity0 has joined #ipfs
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pcardune has quit [Ping timeout: 260 seconds]
lnostdal has quit [Ping timeout: 276 seconds]
colatkinson has joined #ipfs
MikeFair has joined #ipfs
chriscool1 has quit [Ping timeout: 265 seconds]
Guanin_ has quit [Ping timeout: 256 seconds]
PyHedgehog has quit [Quit: Connection closed for inactivity]
Guanin_ has joined #ipfs
colatkinson has quit [Quit: colatkinson]
MikeFair has quit [Ping timeout: 276 seconds]
ulrichard has joined #ipfs
dimitarvp has quit [Quit: Bye]
AgenttiX has quit [Ping timeout: 260 seconds]
colatkinson has joined #ipfs
AgenttiX has joined #ipfs
ONI_Ghost has joined #ipfs
ONI_Ghost has joined #ipfs
ONI_Ghost has quit [Changing host]
bingo has quit [Remote host closed the connection]
bingo has joined #ipfs
fxrs has quit [Quit: ZNC 1.7.x-git-653-187f617 - http://znc.in]
fxrs has joined #ipfs
bingo has quit [Ping timeout: 260 seconds]
bingo has joined #ipfs
bingo has quit [Ping timeout: 255 seconds]
trn has quit [Excess Flood]
kvda has joined #ipfs
jesse22 has joined #ipfs
jesse22 has quit [Client Quit]
jesse22 has joined #ipfs
espadrine_ has quit [Ping timeout: 276 seconds]
trn has joined #ipfs
jesse22_ has joined #ipfs
jesse22 has quit [Ping timeout: 260 seconds]
nicu has joined #ipfs
Guest2936 has quit [Changing host]
Guest2936 has joined #ipfs
Guest2936 has joined #ipfs
Guest2936 is now known as matthiaskrgr
nicu_ has joined #ipfs
nicu has quit [Ping timeout: 276 seconds]
nicu_ is now known as nicu
bingo has joined #ipfs
kvda has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Powersource>
lidel: this might be considerably harder to implement but I think the same principles should apply to pinning. I don't want a random website i give pin rights to to unpin everything that other websites have pinned
<lidel>
yeah defining security constraints for window.ipfs is one of our goals in Q2. current wersion provides basic ACL and Preferences option to deny access globally, we want to refine it both in terms of UX (not nagging user when we can sandbox/scope instead) and security (sniffing/spoofing/fingerprinting)
<Powersource>
sounds good. Now I'm still pretty bad at JS but will the UX of `if (err.message === 'User denied access to ipfs.files.add') { // Fallback` be able to be improved?
bingo has quit []
rcat has joined #ipfs
<lidel>
Powersource, yeah, good idea
hph^ has joined #ipfs
vyzo has quit [Ping timeout: 260 seconds]
zautomata2 has joined #ipfs
chriscool1 has joined #ipfs
vyzo has joined #ipfs
ilyaigpetrov has joined #ipfs
ONI_Ghost has joined #ipfs
ONI_Ghost has quit [Changing host]
ONI_Ghost has joined #ipfs
chriscool1 has quit [Quit: Leaving.]
chriscool1 has joined #ipfs
kchz has joined #ipfs
billyr has quit [Quit: Connection closed for inactivity]
pcardune has joined #ipfs
chriscool1 has quit [Quit: Leaving.]
pcardune has quit [Ping timeout: 260 seconds]
lnostdal has joined #ipfs
Steverman has joined #ipfs
konubinix has quit [Ping timeout: 276 seconds]
konubinix has joined #ipfs
raynold has quit [Quit: Connection closed for inactivity]
drrty2 has quit [Ping timeout: 264 seconds]
anewuser has joined #ipfs
bomb-on has quit [Quit: SO LONG, SUCKERS!]
bomb-on has joined #ipfs
lord| has quit [Quit: WeeChat 2.1]
vivus has joined #ipfs
Guest92 has joined #ipfs
ericxtang has joined #ipfs
Guest92 has quit [Remote host closed the connection]
ONI_Ghost has quit [Read error: Connection reset by peer]
ONI_Ghost has joined #ipfs
xav_ has joined #ipfs
chriscool1 has joined #ipfs
<Taoki>
Hi
brabo has joined #ipfs
<Taoki>
I just enabled the IPFS Companion extension for Firefox, version 2.2.1. I set my node type to Embedded, which I'm very happy to see is finally supported! However when I open an IPFS URL, I'm still being told "cannot connect". Any idea how to fix that please?
<Taoki>
Any thoughts on what might be wrong? I remember it worked fine with go-ipfs running in the background, so this must be an issue of the embedded version.
ericxtang has quit [Remote host closed the connection]
Steverman has quit [Ping timeout: 264 seconds]
xav_ has quit [Ping timeout: 260 seconds]
<lidel>
Taoki, what do you mean by 'cannot connect' ? what URL are you opening/
<lidel>
Taoki, ah, you are using URL of go-ipfs when it is down?
<Taoki>
lidel: I'm no longer running go-ipfs, only did so for testing purposes. I set IPFS Companion to "embedded" mode. I understand IPFS should fully work in-browser now.
<lidel>
Taoki, raw IPFS does, but due to limitations of WebExtension API embedded node does not provide HTTP gateway, so you need to use public one for that.
<Taoki>
Oooh. I thought it would all just work out of the box. I see.
<Taoki>
Will this be fixed later?
<lidel>
Yes, but hard to say when, it is up to browser vendors provide missing API.
<Taoki>
I assume all IPFS functionality is local (seeding by the web browser, etc)
Keagan has joined #ipfs
<lidel>
yes, as long you don't use HTTP gateway, it is local
<Taoki>
I am using https://ipfs.io/ipfs/ like you said, as that's the only thing that works. But I assume all other functionality is handled by the browser now.
Keagan has quit [Client Quit]
<lidel>
Taoki, yes, if you upload an image via browser action, you will notice that content is uploaded via embedded IPFS node, but for user's convenience it gets opened at public HTTP gateway.
<Taoki>
Okay. Thanks :)
<Taoki>
I assume IPFS Companion also provides the js-ipfs-api so I can use IPFS JavaScript functions on page scripts.
<JohnyTheSmith>
Okay... having a problem again with automation. namely, ipfs pin add commands not working via cronjob
Keagan has joined #ipfs
anewuser has quit [Quit: anewuser]
Keagan has quit [Client Quit]
ygrek has quit [Ping timeout: 260 seconds]
dukaanbabu has quit [Quit: Connection closed for inactivity]
icostan[m] has left #ipfs ["User left"]
fazo96_ has joined #ipfs
fazo96 has quit [Ping timeout: 268 seconds]
<Taoki>
Darn; It seems IPFS Companion might be using a lot of memory and CPU in Firefox. Might have to still keep it disabled when not using it.
<JohnyTheSmith>
Yeah, ipfs in general does that
<Taoki>
Might have been something else though, will have to check.
<Taoki>
Yeah
<Taoki>
After restartinf FF it's gone for now.
<Taoki>
It makes sense if IPFS is working or seeding stuff, but otherwise it's a bug if it does this for no reason.
<JohnyTheSmith>
hence why i bought myself a pi to run my node on. And set it up as service so whenever it hangs up due to memory overflow itll be restarted
<Taoki>
lidel: My Linux distribution (openSUSE Tumbleweed) doesn't yet provide go-ipfs as a system-wide package, otherwise I'd enable it at autostart and always run it. Embedded IPFS is thus more convenient for me now.
<Taoki>
I've been poking them in order to ask them to include it, but no response yet.
ulrichard has quit [Remote host closed the connection]
handcraftsman has quit [Remote host closed the connection]
<Poeticode>
This isn't anything new or groundbreaking... But my latest side-project was getting a supah-fast static site on IPFS. It's generated with Hugo, uses Forestry for content-management, and uses Turbolinks in the frontend to pre-fetch all of the pages and make <a href> links use AJAX instead of a full page load. :D to view it via my IPFS gateway: https
<underikar>
How do you get the name resolution so fast?
<Taoki>
Speaking of which: If anyone here is close to the Linux and / or openSUSE community, please gently pester them to add IPFS to the system packages! Or the IPFS developers to create both a deb and rpm software repository that we can all use.
<ToxicFrog>
Taoki: FWIW, anyone can publish a SUSE package on OBS, and I believe OBS also supports building packages for other distros
<Taoki>
Anything that works is fine by me, as long as someone can maintain the packages. I can't compile IPFS and have no experience with maintaining system packages sadly, nor time for the task.
<Taoki>
But tons of other software do it, so it shouldn't be a problem for those with the resources and experience.
<Taoki>
I've kept asking them but so far no response.
<Taoki>
A generic repository that works for all distros should be possible though, as long as library paths aren't a problem. Some programs do that. Just needs to be RPM compatible.
<Poeticode>
underikar: I'm using dnslink, so it's actually using ipfs/hash under the hood and not the slower ipns/hash. And then I've got an apache virtualhost that reverse proxies to the local IPFS gateway
<ToxicFrog>
Taoki: Fedora and CentOS are both RPM based.
<Taoki>
Nice. It might just work then :)
<Taoki>
Awesome
<daftaupe>
try it and tell me :)
<ToxicFrog>
(although I've had some luck installing debian packages on SUSE using alien(1) to convert the packages)
<Taoki>
Library paths are usually the issue. Ifit's not compiled to rely on specifics, it should work
<Taoki>
Will do
<ToxicFrog>
IIRC go favours static linking by default, so you have better odds with go programs than with most things.
<daftaupe>
the one you gave is the one for source-rpms
<daftaupe>
if you want to rebuild them
<JohnyTheSmith>
wtf?
<Taoki>
Nah, looking for the whole thing. The epel one seems to work
<JohnyTheSmith>
no ipfs repo found? Ive been running this for quite a while...
<underikar>
Poeticode: oh i see. but that means that to update the site you need to wait for dns to update
<underikar>
i suppose thats an acceptable workaround
<daftaupe>
let's stop spamming about the rpm here, Taoki pm me if you need
<JohnyTheSmith>
oh...
<JohnyTheSmith>
obviously i have to mount the filesystem...
<JohnyTheSmith>
:D
<Taoki>
ok
tpircs has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<Poeticode>
underikar: yeah :/ I lower the time-to-live for my DNS record during development and raise it back up for production. And then I always find a small bug right after that and have to wait a few hours for the fix to propagate :D
<underikar>
lol
<underikar>
but it gets you much more acceptable resolution times
<underikar>
instead of minutes
fazo96_ has quit [Quit: Konversation terminated!]
pcardune has joined #ipfs
pcardune has quit [Remote host closed the connection]
pcardune has joined #ipfs
droman has quit [Quit: WeeChat 1.9.1]
<Poeticode>
yeah, I'm wondering if I can set up my own DNS (which I should do anyway) and see if I can have it automatically update the dnslink txt record with every build
pcardune has quit [Remote host closed the connection]
pcardune has quit [Remote host closed the connection]
pcardune has joined #ipfs
pcardune_ has joined #ipfs
pcardun__ has joined #ipfs
pcardune_ has quit [Read error: Connection reset by peer]
pcardun__ has quit [Remote host closed the connection]
pcardune_ has joined #ipfs
pcardune has quit [Ping timeout: 260 seconds]
<Poeticode>
thanks victorbjelkholm & lidel :D I'll check em out
mtodor has quit [Quit: Leaving...]
<Poeticode>
kewl, hover has an unofficial DNS api as well, which is what I'm using atm
ericxtang has joined #ipfs
goiko has quit [Ping timeout: 240 seconds]
goiko has joined #ipfs
ericxtan_ has joined #ipfs
ericxtang has quit [Read error: Connection reset by peer]
kchz has quit [Ping timeout: 240 seconds]
raynold has joined #ipfs
kchz has joined #ipfs
Fessus has joined #ipfs
dylxc[m] has joined #ipfs
pcardune_ has quit [Remote host closed the connection]
pcardune has joined #ipfs
}ls{ has joined #ipfs
Neomex has joined #ipfs
kchz has quit [Ping timeout: 265 seconds]
ylp has joined #ipfs
kchz has joined #ipfs
pcardune has quit [Ping timeout: 255 seconds]
kchz has quit [Ping timeout: 260 seconds]
SunflowerSociety has joined #ipfs
SunflowerSociety has joined #ipfs
SunflowerSociety has quit [Changing host]
ONI_Ghost has quit [Read error: Connection reset by peer]
drrty has joined #ipfs
rendar has quit []
Encrypt_1 has joined #ipfs
Sunflowery has joined #ipfs
SunflowerSociety has quit [Ping timeout: 268 seconds]
kchz has joined #ipfs
pcardune has joined #ipfs
pcardune has quit [Ping timeout: 260 seconds]
Encrypt_1 is now known as Encrypt
Keagan has joined #ipfs
espadrine_ has joined #ipfs
Keagan has quit [Read error: Connection reset by peer]
Nukien has quit [Remote host closed the connection]
Nukien has joined #ipfs
gmoro has quit [Ping timeout: 264 seconds]
Sunflowery has quit [Remote host closed the connection]
Sunflowery has joined #ipfs
m3lt has joined #ipfs
modus_ has joined #ipfs
clemo has quit [Remote host closed the connection]
ericxtan_ has quit [Remote host closed the connection]
sim590 has quit [Ping timeout: 256 seconds]
Encrypt has quit [Quit: Quit]
sim590 has joined #ipfs
modus_ has quit [Quit: Leaving]
Steverman has joined #ipfs
ericxtang has joined #ipfs
colatkinson has joined #ipfs
Neomex has quit [Read error: Connection reset by peer]
bomb-on has quit [Quit: SO LONG, SUCKERS!]
ericxtang has quit [Ping timeout: 256 seconds]
pcardune has joined #ipfs
ericxtang has joined #ipfs
Taoki has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
selena-lowell[m] has left #ipfs ["User left"]
shizy has joined #ipfs
pcardune has quit [Remote host closed the connection]
gmoro has joined #ipfs
bomb-on has joined #ipfs
Steverman has quit [Ping timeout: 256 seconds]
Encrypt has joined #ipfs
ericxtang has quit [Remote host closed the connection]
Frozenlock has quit [Remote host closed the connection]
Steverman has joined #ipfs
gmoro has quit [Ping timeout: 260 seconds]
pcardune has joined #ipfs
pcardune has quit [Client Quit]
Alobar has quit [Ping timeout: 264 seconds]
kchz has quit [Quit: ZZzzz…]
colatkinson has quit [Quit: colatkinson]
ashark has quit [Ping timeout: 264 seconds]
ericxtang has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
lnostdal has quit [Read error: Connection reset by peer]
lnostdal has joined #ipfs
ilyaigpetrov has quit [Quit: Connection closed for inactivity]
kaotisk_ has joined #ipfs
kaotisk has quit [Read error: Connection reset by peer]
Ecran has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
lnostdal has quit [Ping timeout: 240 seconds]
colatkinson has joined #ipfs
Steverman has quit [Ping timeout: 268 seconds]
<AphelionZ>
In js-ipfs, what is the config directive for the repo location?
<AphelionZ>
I know you can set it via IPFS_PATH environment variable but is there anything in the config structure
<AphelionZ>
nvn found it: const node = new IPFS({ repo: '/var/ipfs/data' })
ashark has joined #ipfs
Steverman has joined #ipfs
jungly has quit [Remote host closed the connection]
tombusby has quit [Remote host closed the connection]
tombusby has joined #ipfs
colatkinson has quit [Quit: colatkinson]
colatkinson has joined #ipfs
sieuhgisaeg has quit [Quit: WeeChat 1.9.1]
tesla has joined #ipfs
tesla is now known as aeughusegtgt
Steverman has quit [Ping timeout: 256 seconds]
mildred has joined #ipfs
drrty has quit [Ping timeout: 264 seconds]
drrty has joined #ipfs
droman has joined #ipfs
colatkinson has quit [Quit: colatkinson]
ericxtang has quit [Remote host closed the connection]
lord| has joined #ipfs
Mateon3 has joined #ipfs
Mateon1 has quit [Ping timeout: 240 seconds]
Mateon3 is now known as Mateon1
ashark has quit [Ping timeout: 264 seconds]
tenchooo has quit [Remote host closed the connection]
tenchooo has joined #ipfs
dddelta has joined #ipfs
dddelta has left #ipfs ["ERC (IRC client for Emacs 25.3.1)"]
<Guanin_>
When I do ipfs pin on a large directory, does it need to keep a copy of all files?
<Guanin_>
Or asked in another way: Does ipfs pin need any noteworthy additional storage when used on a large directory?
<AphelionZ>
might there be any folks familiar with orbitdb here that aren't in the #orbitdb channel? I'm trying to figure out how to have js-ipfs running in node on one process and be writing to a db, then read from that same db (or a replicated copy) from the cli
<AphelionZ>
Guanin_: iirc ipfs add makes a copy, ipfs pin does not necessarily unless those files haven't already been added
<jkrone>
Guanin_: No, pins are just metadata about the hashes that should not be deleted. The storage required for them is not likely to be significant relative to the files you're adding.
<Guanin_>
Oh, I forgot - I meant add, not pin
<Guanin_>
Didn't use ipfs for a long time, sorry
<Guanin_>
So, I was planning to add around 2TB worth of files, and I am a bit concerned about needing that storage twice
<AphelionZ>
yeah, that's a valid concern... your local file system =/= your ipfs repo
<Guanin_>
although I know that the files won't change :/
<Guanin_>
I'm dumping a website right now and want to make that backup available as a seamless replacement
<jkrone>
There is an experimental feature 'no-copy' on go-ipfs that I believe does not copy. I'm totally unfamiliar with it though
<Guanin_>
Thanks, I'll look into it
Encrypt has quit [Quit: Quit]
ericxtang has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
Steverman has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
Steverman has quit [Ping timeout: 276 seconds]
shizy has quit [Ping timeout: 240 seconds]
ericxtang has quit [Remote host closed the connection]
mildred has quit [Quit: mildred]
Ecran has quit [Quit: Going offline, see ya! (www.adiirc.com)]
chriscool1 has quit [Quit: Leaving.]
ericxtang has joined #ipfs
dimitarvp has quit [Quit: Bye]
ericxtang has quit [Remote host closed the connection]
Steverman has joined #ipfs
<AphelionZ>
is there a way to force orbitdb replication
ericxtan_ has joined #ipfs
ericxtan_ has quit [Remote host closed the connection]