标签: memory-safety

我在CentOS 6.4 32位上,并试图在程序中导致缓冲区溢出.在GDB中它可以工作.这是输出:

[root@localhost bufferoverflow]# gdb stack
GNU gdb (GDB) Red Hat Enterprise Linux (7.2-60.el6_4.1)
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /root/bufferoverflow/stack...done.
(gdb) r …

根据维基百科

如果计算机科学家不允许操作或转换违反类型系统的规则,则认为该语言是"类型安全的".

由于Python运行时检查确保满足类型系统规则,因此我们应该将Python视为一种类型安全的语言.

Jason Orendorff和Jim Blandy在编程Rust中也提出了同样的观点:

请注意,类型安全与语言是否在编译时或运行时检查类型无关:C在编译时检查,并且不是类型安全的; Python在运行时检查,并且类型安全.

既有静态类型检查和类型安全的单独概念.

那是对的吗？

我想用Haskell的quickcheck库测试一些C代码.最简单的方法似乎是 foreign import在最终的haskell函数之上编写一个属性.这样做的问题是,如果C代码导致段错误或设法破坏内存,我的测试要么在没有输出的情况下崩溃,要么做一些完全不可预测的事情.

第二种方法是在C位上创建简单的可执行包装器,并在测试过程之外执行它们System.Process.不用说,这样做需要大量的脚手架和序列化值,但另一方面,它可以处理段错误.

有没有办法让foreign import战略像运行外部流程一样安全？

我已经读过某个地方,在一个具有指针的语言中,编译器无法在编译时完全决定是否所有指针都被正确使用和/或有效(参考活动对象)由于各种原因,因为那样做基本上构成解决停止问题.直觉上这并不奇怪,因为在这种情况下,我们能够在编译期间推断出程序的运行时行为,类似于此相关问题中所述的内容.

但是,据我所知,Rust语言要求指针检查完全在编译时完成(没有与指针相关的未定义行为,至少是"安全"指针,并且没有"无效指针"或"空指针"运行时例外).

假设Rust编译器无法解决暂停问题,那么谬误在哪里呢？

• 是不是指针检查不是完全在编译时完成的,而Rust的智能指针仍然会引入一些运行时开销,比如C中的原始指针？
• 或者Rust编译器是否有可能无法做出完全正确的决策,有时需要Just Trust The Programmer™,可能使用其中一个生命周期注释(具有<'lifetime_ident>语法的注释)？在这种情况下,这是否意味着指针/内存安全保证不是100%,仍然依赖程序员编写正确的代码？
• 另一种可能性是Rust指针在某种意义上是非"通用的"或受限制的,因此编译器可以在编译时完全推断它们的属性,但它们不像C中的原始指针或C++中的智能指针那样有用.
• 或者它可能是完全不同的东西,我误解了一个或多个
  { "pointer", "safety", "guaranteed", "compile-time" }.

我理解的使用和肤浅的差异weak,并unowned在斯威夫特:

我见过的最简单的例子是,如果有a Dog和a Bone,则Bone可能有弱引用Dog(反之亦然)因为每个可以彼此独立存在.

在另一方面,在的情况下Human和Heart,则Heart可能有一个unowned人类的参考,因为一旦Human变成......"引用",将Heart不能再合理地进行访问.那和经典的例子一起Customer和CreditCard.

所以这不是问题的重复.

我的问题是,有两个这样相似的概念有什么意义？内部差异是什么,需要两个关键字,看起来基本上99%相同的东西？问题是为什么存在差异,而不是存在差异.

鉴于我们可以像这样设置一个变量:weak var customer: Customer!,unowned变量不可选的优点是一个有争议的问题.

我可以看到使用vs隐式展开变量via 的唯一实际优点是我们可以通过引用使引用保持不变.unownedweak!unownedlet

......也许编译器可以为此做出更有效的优化.

这是真的,还是在幕后发生了其他事情,为保留两个关键词提供了令人信服的论据(尽管略有区别 - 基于Stack Overflow流量 - 显然让新的和经验丰富的开发人员感到困惑).

我最感兴趣的是听过那些使用过Swift编译器(或其他编译器)的人.

随着 Deno 成为 Node.js 的新竞争对手，许多新闻文章都提到了 Rust 的内存安全特性，其中一篇特别的文章指出 Rust 和 Go 因其内存安全特性而受益，Swift 和 Kotlin 也是如此但后两者并没有广泛用于系统编程。

Safe Rust 是真正的 Rust 编程语言。如果您所做的只是编写 Safe Rust，您将永远不必担心类型安全或内存安全。您永远不会忍受悬空指针、释放后使用或任何其他类型的未定义行为。

这激起了我的兴趣，想了解 Python 是否可以被视为内存安全，如果是或否，安全或不安全的程度如何？

从一开始，维基百科上关于内存安全的文章就没有提到Python，而关于Python的文章似乎只提到了内存管理。我最接近找到答案的是Daniel 的这个：

维基百科文章将类型安全与内存安全相关联，这意味着同一内存区域不能作为整数和字符串进行访问。这样Python就是类型安全的。您不能隐式更改对象的类型。

但即便如此，这似乎也仅仅暗示了两个方面之间的联系（使用维基百科的关联，这又是有争议的），并且对于 Python 是否可以被视为内存安全没有明确的答案。

是否可以创建编码标准或使用可以证明可以消除C++中的任何内存管理错误的库？

我正在考虑类似Java的东西,例如在Java应用程序中悬挂指针是不可能的.

我一直试图了解Rust的借款和所有权模式.

假设我们有以下代码:

fn main() {
    let a = String::from("short");
    {
        let b = String::from("a long long long string");
        println!("{}", min(&a, &b));
    }
}

fn min<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() < b.len() {
        return a;
    } else {
        return b;
    }
}

min()只返回对两个引用字符串中较短者的引用.main()传递两个字符串引用,其引用在不同的范围内定义.我已经使用过,String::from()因此引用没有静态生命周期.程序正确打印short.以下是Rust Playground中的示例.

如果我们引用Rustonomicon(我欣赏它是一个正在进行的工作文档),我们被告知函数签名的含义如下:

fn as_str<'a>(data: &'a u32) -> &'a str

意味着功能:

引用一个u32有生命周期的东西,并承诺它可以产生一个str可以存活一段时间的引用.

现在让我们转向 …

如果我有一个封装两个成员的结构,并根据另一个更新一个,只要我这样做就可以了:

struct A {
    value: i64
}

impl A {
    pub fn new() -> Self {
        A { value: 0 }
    }
    pub fn do_something(&mut self, other: &B) {
        self.value += other.value;
    }
    pub fn value(&self) -> i64 {
        self.value
    }
}

struct B {
    pub value: i64
}

struct State {
    a: A,
    b: B
}

impl State {
    pub fn new() -> Self {
        State {
            a: A::new(),
            b: B { value: 1 }
        }
    }
    pub fn …

我将一些较旧的高速 C++ 代码移植到 C#，现有代码使用了这样的基于指针的双间接模式（此处以 C# 语法编写），使用堆栈作为高效的临时存储：

public struct Source {\n    public byte* Start;\n    public int Count;\n}\n\npublic struct SourceSet {\n    public Source* Start;\n    public int Count;\n}\n\nSource* sources = stackalloc Source[n*k];\nSourceSet* sourceSets = stackalloc SourceSet[n];\n

sources它用数据段的集合填充，并用每组中有sourceSets多少个来填充 。Source

该代码工作正常，但理想情况下，我想将其转换为不再使用指针和unsafe\xe2\x80\x94 来代替使用像这样的内存安全的东西，其中每个都由一个源SourceSet填充：.Slice()

public struct Source {\n    public int Start;\n    public int Count;\n}\n\nSpan<Source> sources = stackalloc Source[n*k];\nSpan<Span<Source>> sourceSets = stackalloc Span<Source>[n];\n

但我不能这么写，因为Span<Span<T>>C# 中不能存在 \xe2\x80\x94Span<T>是 a ref struct，因此不能用作 …