## cryptography – Result of the Needham-Schroeder protocol

I study the Needham-Schroeder protocol in my course subject and I understood it well, but there is a homework problem that asks: "what is the result of the Needham-Schroeder protocol?"

In my opinion, this results in a security session between Alice and Bob for communication and kdc is responsible for this security session. Is my answer correct or is this question something else?

## wordpress – Is CloudFlare's full SSL protocol less secure than Cloudflace strict (strict) SSL?

I have Linux shared hosting on Hostgator, and I use a Full Cloudflare SSL which End-to-end digit, using a self-signed certificate on the server.

1. Is it safe?

2. What are the different options to enable full security if this method has disadvantages?

Cloudflare has a stricter SSL option that is Complete (strict)
that encrypts end-to-end, but requires a Cloudflare trusted or original certificate authority certificate on the serverI do not use it for the moment.

## middle man – Why is the HTTP protocol more likely to be intercepted than the BitTorrent protocol?

The difference is that the BitTorrent protocol has a mechanism to verify that you have received what you want to receive, unlike HTTP.

HTTP has no mechanism to verify that you are actually connected to the server to which you want to connect. In theory, if circumstances permit, HTTP is susceptible to a man-in-the-middle attack. This means that, from your side, it looks like you're connected to example.com, but in reality you're connected to a third party that intercepts traffic, manipulates network traffic and just gives the impression that you are connected to example.com. You then ask to download a certain file, but the man (or woman) in the center sends you a malicious file. (On one side, HTTPS correctly configured, with `S`, prevents this.)

A file transmitted via BitTorrent is first divided into pieces. Each of these pieces is then chopped using SHA-1, that is, a checksum is generated by the creator of the torrent. Hashes are assigned to each BitTorrent client before the download – usually contained in a file. `.torrent` file. As the file pieces are then downloaded by the client, they are first hashed by the client itself, and then compared to the previously received hash. It is accepted only if the hash matches, which means that the block contains exactly the same bytes as the expected block. It is virtually impossible to make altered pieces with malicious content, but keeping their original hash.

Since these hashes are shared with you before the download, probably from a trusted source, it is harder (if not impossible) to handle the expected file or files in transit when they are received via BitTorrent compared to an HTTP download.

If your hash or torrent files are handled before the download, the checksum validation does not provide any security.

## put on hold as unclear what you ask by John Conde♦2 days ago

Please clarify your specific problem or add additional details to highlight exactly what you need. As it stands, it's hard to say exactly what you're asking for. Refer to the How to Ask Questions page for help clarifying this question. If this question can be rephrased to fit the rules in the Help Center, edit it.

## open graphical protocol – The Twitter card on Twitter with a large image disappears after a week or two

I let users upload URLs to share on Twitter and they get `twitter:image` like a big picture card. They go well at first, but after a while (about a week), they disappear and look like the Twitter card below. How could I solve this problem? They work on mobile phones but not on the web. Is not this normal but serviceable behavior of Twitter? My meta tags seem to be correct and are below?

``` ```

## Electrum – Electrumx Protocol – Bitcoin Battery Exchange

The description says:

``````A script hash is the hash of the binary bytes of the locking script (ScriptPubKey), expressed as a hexadecimal string. The hash function to use is given by the “hash_function” member of server.features() (currently sha256() only). Like for block and transaction hashes, when converting the big-endian binary hash to a hexadecimal string the least-significant byte appears first, and the most-significant byte last.

For example, the legacy Bitcoin address from the genesis block:

1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa
has P2PKH script:

76a91462e907b15cbf27d5425399ebf6f0fb50ebb88f1888ac
with SHA256 hash:

6191c3b590bfcfa0475e877c302da1e323497acf3b42c08d8fa28e364edf018b
which is sent to the server reversed as:

8b01df4e368ea28f8dc0423bcf7a4923e3a12d307c875e47a0cfbf90b5c39161
By subscribing to this hash you can find P2PKH payments to that address.
``````

Can any one explain what these numbers are:

6191c3b590bfcfa0475e877c302da1e323497acf3b42c08d8fa28e364edf018b

8b01df4e368ea28f8dc0423bcf7a4923e3a12d307c875e47a0cfbf90b5c39161

and how to get them?

## put on hold as unclear what you ask by John Conde♦1 hour ago

Please clarify your specific problem or add additional details to highlight exactly what you need. As it stands, it's hard to say exactly what you're asking for. Refer to the How to Ask Questions page for help clarifying this question. If this question can be rephrased to fit the rules in the Help Center, edit it.

## Database Theory – Does the timestamping protocol that follows the thomas write rule allow in some cases schedules that can not be seen?

I came across the following line in a manual (Database System Concepts
Manuel Avi Silberschatz, Henry F. Korth and S. Sudarshan $$6e$$) page no. 686:

Thomas's writing rule allows non-conflicting schedules
but are nevertheless correct. Those non-conflict-serializable
allowed times meet the definition of serializable view
times (see example).

What I understood from the lines above is that each program generated by the timestamp protocol following the thomas write rule is a serializable view.

Now let's take the following small schedule: $$S: R_1 (X), W_2 (X), W_1 (X)$$.

This schedule $$S$$ is allowed by the timestamp protocol that follows the thomas writing rule.

And the order of serialization is $$R_1 (X), W_1 (X).$$

But I could not prove that it is a serializable view.

In fact, I think it's non-serializable view because,

1. Consider serial order as $$T_1, T_2$$

Now the final value of $$X$$ is written by $$T_2$$. So not equivalent.

2. The next alternative order is $$T_2, T_1$$

right here, $$R_1 (X)$$ will read the value of $$X$$ written by $$T_1$$ not the original value
who was there before the start of the transaction. So, this is not
equivalent of view.

What's wrong here.

## Swift Protocol with Lazy Property Requirement

First question here on CodeReview. I've been headed here by a question I asked SO, here: https://stackoverflow.com/questions/58364613/swift-protocol-with-lazy-property-cannot-use-mutating -getter-on-immutable-worth / 58364648

Objective: To create a protocol that allows lazy computing of a property for protocol-compliant structures. The calculation is intensive and should only be performed once, hence the lazy requirement.

So, after a lot of reading (for example this: https://stackoverflow.com/questions/28202834/swift-struct-with-lazy-private-property-conforming-to-protocol, where I based this code on) and trial and error, I came up with something that works:

``````import Foundation

protocol Foo {
var footype: Double { mutating get }

func calculateFoo() -> Double
}

struct Bar: Foo {
private lazy var _footype: Double = {
let value = calculateFoo()

return value
}()

var footype: Double {
mutating get {
return _footype
}
}

func calculateFoo() -> Double {
print("calc")
return 3.453
}
}
``````

Test this in a playground:

``````var bar = Bar()
print(bar.footype)
print(bar.footype)
``````

And the result is:

``````calc
3.453
3.453
``````

So it works. But that sounds like a hack using `_footype`

In the comments also, it was suggested that

However, I would not put CalculateFoo in the protocol because it looks like an implementation detail.

Layer `A` is the protocol and the layer of higher level `C` is the lower level protocol. Each layer has its distinct features. These layers must communicate with each other. To my knowledge, we can simply call methods of `protocol layer B` of `A`the methods of.
Recently, I learned that this layered communication can be implemented in the form of different entities (threads) and that they wait on a specific queue to receive messages. other layers. In C ++ terms, I can think of using `std::queue`, std :: thread and synchronize read and write to the queue using mutex and conditional variables.
Before implementing this queuing mechanism messages, I would like to know if I lack a level of abstraction (key consideration). I do not need any `C++` Specific implementation details, but if you provide, it's a plus for me.